Is it possible to unpack a tuple into function arguments?

Question

If I want to unpack a tuple and pass it as arguments is there a way to do this:

//Does not compile fn main() {     let tuple = (10, Vec::new());     foo(tuple); } fn foo(a: i32, b: Vec<i32>) {     //Does stuff. } 

Instead of having to do this:

fn main() {     let tuple = (10, Vec::new());     foo(tuple.0, tuple.1); } fn foo(a: i32, b: Vec<i32>) {     //Does stuff. } 

Answer 1

On a nightly compiler:

#![feature(fn_traits)]  fn main() {     let tuple = (10, Vec::new());     std::ops::Fn::call(&foo, tuple); } fn foo(a: i32, b: Vec<i32>) { } 

There is AFAIK no stable way to do that.

Answer 2

There is a way, using the magic of pattern matching:

fn main() {     let tuple = (10, Vec::new());     foo(tuple); }  fn foo((a, b): (i32, Vec<i32>)) {     // do stuff } 

As per Rust reference:

As with let bindings, function arguments are irrefutable patterns, so any pattern that is valid in a let binding is also valid as an argument.

So you can specify an argument like:

(a, b): (i32, Vec<i32>) 

just like you would in a let statement.