जंग

Question

में किसी सरणी से कॉलिंग बंद करना मैं बंद होने की एक सरणी पर फिर से कैसे घुमाता हूं, प्रत्येक को बदले में बुलाता हूं?

कार्यों के साथ, मैं मैं सिर्फ सरणी पर पुनरावृत्ति, और मूल्यों का उत्पादन किया अपसंदर्भन से ऐसा कर सकता है की खोज की:

fn square(x: int) -> int { x * x } 

fn add_one(x: int) -> int { x + 1 } 

fn main() { 
    let funcs = [square, add_one]; 
    for func in funcs.iter() { 
     println!("{}", (*func)(5i)); 
    } 
} 

हालांकि, जब मैं बंद साथ भी ऐसा ही करने की कोशिश, मैं कोई त्रुटि मिलती है :

fn main() { 
    let closures = [|x: int| x * x, |x| x + 1]; 
    for closure in closures.iter() { 
     println!("{}", (*closure)(10i)); 
    } 
} 

का उत्पादन:

<anon>:4:24: 4:34 error: closure invocation in a `&` reference 
<anon>:4   println!("{}", (*closure)(10i)); 
           ^~~~~~~~~~ 
note: in expansion of format_args! 
<std macros>:2:23: 2:77 note: expansion site 
<std macros>:1:1: 3:2 note: in expansion of println! 
<anon>:4:9: 4:41 note: expansion site 
<anon>:4:24: 4:34 note: closures behind references must be called via `&mut` 
<anon>:4   println!("{}", (*closure)(10i)); 
           ^~~~~~~~~~ 
note: in expansion of format_args! 
<std macros>:2:23: 2:77 note: expansion site 
<std macros>:1:1: 3:2 note: in expansion of println! 
<anon>:4:9: 4:41 note: expansion site 

मैं यात्रा vari घोषित करने की कोशिश करते हैं सक्षम ref mut, यह अभी भी काम नहीं करता:

fn main() { 
    let closures = [|x: int| x * x, |x| x + 1]; 
    for ref mut closure in closures.iter() { 
     println!("{}", (*closure)(10i)); 
    } 
} 

परिणाम में:

<anon>:4:24: 4:39 error: expected function, found `&|int| -> int` 
<anon>:4   println!("{}", (*closure)(10i)); 
           ^~~~~~~~~~~~~~~ 
note: in expansion of format_args! 
<std macros>:2:23: 2:77 note: expansion site 
<std macros>:1:1: 3:2 note: in expansion of println! 
<anon>:4:9: 4:41 note: expansion site 

मैं एक और भिन्नता जोड़ देते हैं तो:

fn main() { 
    let closures = [|x: int| x * x, |x| x + 1]; 
    for ref mut closure in closures.iter() { 
     println!("{}", (**closure)(10i)); 
    } 
} 

मैं मूल त्रुटि को वापस पाने:

<anon>:4:24: 4:35 error: closure invocation in a `&` reference 
<anon>:4   println!("{}", (**closure)(10i)); 
           ^~~~~~~~~~~ 
note: in expansion of format_args! 
<std macros>:2:23: 2:77 note: expansion site 
<std macros>:1:1: 3:2 note: in expansion of println! 
<anon>:4:9: 4:42 note: expansion site 
<anon>:4:24: 4:35 note: closures behind references must be called via `&mut` 
<anon>:4   println!("{}", (**closure)(10i)); 
           ^~~~~~~~~~~ 
note: in expansion of format_args! 
<std macros>:2:23: 2:77 note: expansion site 
<std macros>:1:1: 3:2 note: in expansion of println! 
<anon>:4:9: 4:42 note: expansion site 

मैं यहाँ क्या याद कर रहा हूँ? क्या वहां कहीं दस्तावेज है जो वर्णन करता है कि यह कैसे काम करता है?

Answer 1

वेक्टर पैदावार अपरिवर्तनीय संदर्भ की .iter() विधि, आप परिवर्तनशील लोगों की जरूरत है बंद कॉल करने के लिए, इस प्रकार आप .iter_mut() उपयोग करना चाहिए:

fn main() { 
    let mut closures = [|x: int| x * x, |x| x + 1]; 
    for closure in closures.iter_mut() { 
     println!("{}", (*closure)(10i)); 
    } 
} 

----- 

100 
11