Spread and Rest

const array = [1, 2, 3, 4, 5];
 
console.log(...array); // 1 2 3 4 5

package main
 
import "fmt"
 
func main() {
	array := []byte{1, 2, 3, 4, 5}
 
	var i []any // any = interface{}, can hold elements of different types
	for _, value := range array {
		i = append(i, value)
	}
 
	fmt.Println(i...) // 1 2 3 4 5
}

fn main() {
    let array = [1, 2, 3, 4, 5];
 
    // Rust has no spread; a fixed-size array can be destructured through a
    // pattern and printed variable by variable — it doesn't generalize to
    // a dynamically-sized array.
    let [a, b, c, d, e] = array;
    println!("{a} {b} {c} {d} {e}"); // 1 2 3 4 5
}

let array = [1, 2, 3, 4, 5]
 
// Swift doesn't spread an array into a variadic parameter; join it by hand.
print(array.map(String.init).joined(separator: " ")) // 1 2 3 4 5

static String joinAll(Object... items) {
    return Arrays.stream(items).map(String::valueOf).collect(Collectors.joining(" "));
}
 
void main() {
    Integer[] array = {1, 2, 3, 4, 5};
 
    // passing an existing array straight into a varargs parameter — the
    // closest thing to spread
    IO.println(joinAll((Object[]) array)); // 1 2 3 4 5
}

function sum(...nums) {
  let t = 0;
 
  for (let n of nums) {
    t += n;
  }
 
  return t;
}
 
console.log(sum(1, 2, 3, 4, 5)); // 15

func sum(nums ...int) int {
	var t int
	for _, n := range nums {
		t += n
	}
 
	return t
}
 
func main() {
	fmt.Println(sum(1, 2, 3, 4, 5)) // 15
}

// Rust has no real variadic functions; the closest equivalent is a slice parameter.
fn sum(nums: &[i32]) -> i32 {
    nums.iter().sum()
}
 
fn main() {
    println!("{}", sum(&[1, 2, 3, 4, 5])); // 15
}

// Swift has real variadic parameters — the closest match to JS rest.
func sum(_ nums: Int...) -> Int {
    nums.reduce(0, +)
}
 
print(sum(1, 2, 3, 4, 5)) // 15

// Java also has real variadic parameters.
static int sum(int... nums) {
    int total = 0;
    for (int n : nums) total += n;
    return total;
}
 
void main() {
    IO.println(sum(1, 2, 3, 4, 5)); // 15
}