तर्क में Unpacking tuples

Question

मैं एक टपल खोल और इसे पारित करने के रूप में तर्क वहाँ यह करने के लिए एक तरीका है चाहते हैं:

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

इसके बजाय यह करने के लिए होने के

:

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

Answer 1

एक रात के कंपाइलर पर:

#![feature(fn_traits)] 

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

AFA है आईके ऐसा करने का कोई स्थिर तरीका नहीं है।

Answer 2

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

Answer 3

एक तरीका होता है, पैटर्न मिलान के जादू का उपयोग कर:

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

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

के अनुसार Rust reference:

लेट बाइंडिंग के साथ के रूप में, समारोह तर्क अकाट्य पैटर्न, किसी भी पैटर्न है कि कर रहे हैं तो एक लेट बाध्यकारी में मान्य तर्क के रूप में भी मान्य है। वैसा ही जैसे एक let बयान में होगा

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

:

तो आप की तरह एक तर्क निर्दिष्ट कर सकते हैं।