Using tuples as arguments

[brain113]

In rust we have possibility to return several values in tuple. But we can't use it vice versa: to put several arguments to function in tuple. Like this:

fn main() {
    sum(prepare_args());
}

fn sum(x: int, y: int) -> int {
    x + y
}

fn prepare_args () -> (int, int) {
    (1, 2)
}

I think it will be very usefull.

[jdm]

This is already possible, just not automatically like your snippet suggests:

fn sum((x, y): (int, int)) -> int {

[jfager]

You could go the apply route a la lisp:

fn apply<A,B,C>(f: |A,B|->C, t: (A,B)) -> C {
    let (a,b) = t;
    f(a,b)
}

fn main() {
    apply(sum, prepare_args());
}

I believe you should be able to mimic Scala's tupled w/ unboxed closures, but I'm not sure if that's possible yet.

[ftxqxd]

Variadic generics adds a similar feature to Rust, but with a more explicit syntax: foo(..(1, 2, 3)) == foo(1, 2, 3). Unfortunately, we’re probably not going to get variadic generics (at least not before 1.0).

[pcwalton]

"Before 1.0" isn't relevant; Rust is on a rolling release model.

[thestinger]

A language change like this should be proposed through the RFC process:

https://github.com/rust-lang/rfcs

An issue like this isn't actionable because a clear design and consensus to implement it are required before making language changes.