Tuple splat / apply in Rust

Question

I found this discussion about tuple splatting, but it is from 2014.

The example given is:

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

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

fn main() {
    sum(prepare_args()); // Doesn't work
}

And the proposed solution is to roll your own apply function:

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());
}

Is this currently the best way to go? If so, what is the correct syntax here? I get some errors including expected type, found|at line 1 col 20 using the above.

Is there still no tuple splat operator?

Answer 1

I don't think there is a splat operator.

The code you found from 2014 is from before Rust 1.0, so it is outdated. To make the apply function work in post 1.0 Rust, change it into the following:

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

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

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

fn main() {
    let x = apply(sum, prepare_args());
    println!("{}", x);
}

This code compiles and runs correctly on the Rust playground.

You could alternatively use f(t.0, t.1) as the body of apply, or destructure right there in the parameter list (Playground):

fn apply<A, B, C, F>(f: F, (a, b): (A, B)) -> C
    where F : Fn(A, B) -> C
{
    f(a, b)
}