जंग में प्रतिबिंब संभव है, और यदि ऐसा है तो मैं कुछ तर्कों के साथ एक अज्ञात कार्य कैसे कर सकता हूं?

Question

मुझे लंबे समय तक एक सी # प्रोग्रामर होने के साथ जंग के साथ खेलने में बहुत मज़ा आता है लेकिन मेरे पास प्रतिबिंब के आसपास एक सवाल है।

ठीक है, मुझे लगता है कि प्रतिबिंब, शायद मुझे इस मामले में प्रतिबिंब की आवश्यकता नहीं है, लेकिन जंग को दृढ़ता से टाइप किया गया है, मुझे संदेह है कि मैं करता हूं (मुझे निश्चित रूप से इसे अच्छे ओएल 'सी # में चाहिए, इसके सूती मोजे को आशीर्वाद दें)।

ठीक है, तो कहते हैं कि मैं इस स्थिति है:

fn invoke_an_unknown_function(hashmap::HashMap<~str, ~str> 
    /*, Something to denote a function I know nothing about goes here */) 
{ 
    // For each key in the hash map, assign the value 
    // to the parameter argument whose name is the key 
    // and then invoke the function 
} 

मैं ऐसा कैसे होगा? मुझे लगता है कि मुझे किसी प्रकार के MethodInfo में फ़ंक्शन के दूसरे तर्क के रूप में पास करने की आवश्यकता है और उसके बाद उन तर्कों को प्राप्त करने के लिए इसके साथ पोक करें जिनके नाम हैश मानचित्र में कुंजी है और मान असाइन करें लेकिन मैंने इसके लिए चारों ओर देखा

• Module std::reflect
• Module std::repr
• [rust-dev] Reflection system

लेकिन उनमें से कोई भी वास्तव में पर जाने के लिए पर्याप्त मुझे दे आरंभ करने के लिए: प्रतिबिंब एपीआई और निम्न पाया। तो, मैं ऊपर बताए गए फ़ंक्शन को कैसे कार्यान्वित करूं?

Answer 1

लक्षण कहीं और के लिए उपयोग किए जाने वाले प्रतिबिंब (एबी) की उचित मात्रा को लागू करने का अपेक्षित तरीका है।

trait SomeInterface 
{ 
    fn exposed1(&self, a: &str) -> bool; 
    fn exposed2(&self, b: int) -> int; 
} 

struct Implementation1 
{ 
    value: int, 
    hasFoo: bool 
} 

impl SomeInterface for Implementation1 
{ 
    fn exposed1(&self, a: &str) -> bool 
    { 
     self.hasFoo 
    } 

    fn exposed2(&self, b: int) -> int 
    { 
     self.value * b 
    } 
} 

fn test_interface(obj: &SomeInterface) 
{ 
    println!("{}", obj.exposed2(3)); 
} 

fn main() 
{ 
    let impl1 = Implementation1 { value: 1, hasFoo: false }; 
    test_interface(&impl1); 
}