क्या एक गैर-जेनेरिक संरचना जंग में एक सामान्य कार्य को लागू कर सकती है, जो इस तरह काम करती है:


struct S;

impl <T> S {
    fn do_something(value : T) {
        //do something
    }
}

fn main() {
    let a = /*a value*/;
    S::do_something(a);
}

यदि नहीं, तो मान लें कि S एक सामान्य विशेषता Tt लागू करता है:


struct S;

impl <T> Tt<T> for S {
    fn a_func(value : T) {
        //do something
    }
}

impl <T> S {
    fn do_something(value : T) {
        //do something
    }
}

fn main() {
    let a = /*a value*/;
    S::do_something(a);
}

क्या इसे काम करने का कोई तरीका है?

2
Riton Elion 4 जुलाई 2019, 18:37

1 उत्तर

सबसे बढ़िया उत्तर

आप केवल impl ब्लॉक के लिए टाइप वैरिएबल घोषित कर सकते हैं, यदि इसका उपयोग टाइप में ही किया जाता है।

हालाँकि, आप अलग-अलग तरीकों पर भी नए प्रकार के चर पेश कर सकते हैं:

impl S {
    fn do_something<T>(value: T) {
        //do something
    }
}

यह उन तर्कों के लिए विशेष रूप से सामान्य है जो बंद हैं, क्योंकि प्रत्येक बंद का एक अलग प्रकार होता है, इसलिए यह आवश्यक है कि आप हर बार एक अलग बंद के साथ विधि को कॉल करने में सक्षम हों। उदाहरण के लिए, Iterator::map इस तरह परिभाषित किया गया है:

fn map<B, F>(self, f: F) -> Map<Self, F>
where
    F: FnMut(Self::Item) -> B, 

यदि F को विधि के बजाय प्रकार के लिए घोषित किया गया था तो आपको हर बार map को कॉल करने पर उसी क्लोजर का उपयोग करना होगा - बहुत उपयोगी नहीं है।

1
Peter Hall 4 जुलाई 2019, 15:49