Auspacken Tupeln in Argumente

Question

Wenn ich will ein Tupel entpacken und geben es als Argumente gibt es eine Möglichkeit, dies zu tun:

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

Statt der dies zu tun:

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

Answer 1

Auf einem nächtlichen Compiler:

#![feature(fn_traits)] 

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

AFA Es gibt IK keine stabile Möglichkeit, das zu tun.

Answer 2

let (a, b) = (10, Vec::new()); 
foo(a, b); 

Answer 3

Es gibt einen Weg, um die Magie des Pattern-Matching mit:

fn main() { 
    let tuple = (10, Vec::new()); 
    foo(tuple); 
} 

fn foo((a, b): (i32, Vec<i32>)) { 
    // do stuff 
} 

Per Rust reference:

Wie bei let-Bindungen, Funktionsargumente unwiderlegbare Muster sind, so jedes Muster, das ist gültig in einer Let-Bindung ist auch gültig als Argument.

So können Sie ein Argument wie angeben:

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

wie würden Sie in einer let Aussage.