कैसे निम्नलिखित जंग कार्यक्रम को देखते हुए जंग

Question

में तर्क के रूप में एक समारोह के पारित करने के लिए:

fn call_twice<A>(val: A, f: fn(A) -> A) -> A { 
    f(f(val)) 
} 

fn main() { 
    fn double(x: int) -> int {x + x}; 
    println!("Res is {}", call_twice(10i, double)); 
    // println!("Res is {}", call_twice(10i, (x: int) -> int {x + x})); 
    //^this line will fail 
} 

मैं double समारोह के रूप में क्यों पारित कर सकते हैं, लेकिन inlined नहीं? समारोह को परिभाषित किए बिना एक ही व्यवहार को प्राप्त करने का एक अच्छा तरीका क्या है?

Answer 1

2016-04-01 अपडेट:

जंग 1.0 के रूप में, कोड इस तरह दिखना चाहिए:

fn call_twice<A, F>(val: A, mut f: F) -> A 
where F: FnMut(A) -> A { 
    let tmp = f(val); 
    f(tmp) 
} 

fn main() { 
    fn double(x: i32) -> i32 {x + x}; 
    println!("Res is {}", call_twice(10, double)); 
    println!("Res is {}", call_twice(10, |x| x + x)); 
} 

बंद पैरामीटर के लिए परिवर्तन है, क्योंकि बंद अब हैं अनबॉक्स्ड ।

मूल:

जहां तक ​​मुझे पता है, आप इनलाइन ऐसे ही कार्यों को परिभाषित नहीं कर सकते।

आप क्या चाहते हैं एक बंद है। निम्नलिखित काम करता है:

fn call_twice<A>(val: A, f: |A| -> A) -> A { 
    let tmp = f(val); 
    f(tmp) 
} 

fn main() { 
    fn double(x: int) -> int {x + x}; 
    println!("Res is {}", call_twice(10i, double)); 
    println!("Res is {}", call_twice(10i, |x| x + x)); 
} 

में कुछ बातों का ध्यान रखना हैं:

1. कार्य बंद करने के लिए मजबूर है, लेकिन विपरीत सच नहीं है।

2. उधार नियमों के कारण आपको अस्थायी रूप से f(val) का परिणाम स्टोर करने की आवश्यकता है। लघु संस्करण: आपको इसे कॉल करने के बंद होने के लिए अनूठी पहुंच की आवश्यकता है, और उधारकर्ता चेकर पर्याप्त रूप से पर्याप्त नहीं है, यह समझने के लिए कि दो कॉल उनके मूल पदों में स्वतंत्र हैं।

3. क्लोजर अनबॉक्स किए गए बंद द्वारा प्रतिस्थापित होने की प्रक्रिया में हैं, इसलिए यह भविष्य में बदल जाएगा, लेकिन हम अभी तक काफी नहीं हैं।