क्या एक सामान्य फ़ंक्शन के विभिन्न उदाहरणों के लिए अलग-अलग स्थिर चर होने के लिए यह संभव है?

Question

जब मैं सामान्य कार्यों में स्थिर चर का उपयोग करता हूं, जेनेरिक फ़ंक्शन के प्रत्येक उदाहरण में चर की इकाइयां समान होती हैं।

उदाहरण के लिए, इस कोड को

fn foo<T>() { 
    use std::sync::{Once, ONCE_INIT}; 

    static INIT: Once = ONCE_INIT; 

    INIT.call_once(|| { 
     // run initialization here 
     println!("Called"); 
    }); 
} 

fn main() { 
    foo::<i64>(); 
    foo::<i64>(); 
    foo::<isize>(); 
} 

println! में सिर्फ एक बार कहा जाता है।

मैं जंग का मैदान का उपयोग कर विधानसभा कोड की जाँच की और देखा कि INIT चर के प्रकार T वास्तव में हालांकि foo<T> खुद को भिन्न नाम के साथ instantiated कर रहे हैं स्वतंत्र है था।

क्या सामान्य फ़ंक्शन के विभिन्न उदाहरणों के लिए अलग-अलग स्थिर चर होने के लिए यह संभव है ताकि println! को उपरोक्त उदाहरण में दो बार बुलाया जा सके?

Answer 1

नहीं जंग एक सामान्य पैरामीटर से जुड़े स्थिर डेटा को समर्थन देने का समर्थन नहीं करता है।

निकटतम वर्कअराउंड जो मैं सोच सकता हूं, typemap क्रेट जैसे कुछ प्रकार प्रति प्रविष्टि स्टोर करने के लिए उपयोग करना होगा।

/*! 
Add to `Cargo.toml`: 

```cargo 
[dependencies] 
lazy_static = "0.2.8" 
typemap = "0.3.3" 
``` 
*/ 
#[macro_use] extern crate lazy_static; 
extern crate typemap; 

fn main() { 
    foo::<i64>(); 
    foo::<i64>(); 
    foo::<isize>(); 
} 

fn foo<T: 'static>() { 
    use std::marker::PhantomData; 
    use std::sync::Mutex; 
    use typemap::{ShareMap, TypeMap}; 

    // Use `fn(T)` as it avoids having to require that `T` implement 
    // `Send + Sync`. 
    struct Key<T>(PhantomData<fn(T)>); 

    impl<T: 'static> typemap::Key for Key<T> { 
     type Value =(); 
    } 

    lazy_static! { 
     static ref INIT: Mutex<ShareMap> = Mutex::new(TypeMap::custom()); 
    } 

    INIT.lock().unwrap().entry::<Key<T>>().or_insert_with(|| { 
     println!("Called"); 
    }); 
}