जेनेरिक और फ़ंक्शंस

जेनेरिक्स आपको विभिन्न डेटा प्रकारों के लिए तर्क के दोहराव से बचने के लिए लचीला, पुन: प्रयोज्य कोड लिखने की अनुमति देता है। विभिन्न प्रकारों (जैसे i32, f64, या String) के लिए कई कार्यों या संरचनाओं को परिभाषित करने के बजाय, हम एक सामान्य प्रकार के पैरामीटर का उपयोग कर सकते हैं, जिसे पारंपरिक रूप से अक्षर T द्वारा दर्शाया जाता है।

रस्ट कंपाइलर मोनोमॉर्फाइज़ेशन नामक प्रक्रिया का उपयोग करके जेनेरिक का प्रबंधन करता है: संकलन के दौरान, यह वास्तव में उपयोग किए जाने वाले प्रत्येक ठोस प्रकार के लिए जेनेरिक कोड की एक प्रति उत्पन्न करता है। इसका मतलब है कि शून्य रनटाइम प्रदर्शन ओवरहेड है।

सामान्य कार्य

एक सामान्य फ़ंक्शन को परिभाषित करने के लिए, हम फ़ंक्शन नाम के ठीक बाद और तर्क सूची से पहले टाइप पैरामीटर <T> डालते हैं:

fn print_value<T: std::fmt::Debug>(value: T) {
    println!("Value: {:?}", value);
}

सामान्य कार्यों में, हम तर्क प्रकार और रिटर्न प्रकार दोनों के लिए सामान्य प्रकार T का उपयोग कर सकते हैं:

fn identity<T>(value: T) -> T {
    value
}

सामान्य संरचनाएँ

हम लचीले क्षेत्रों को परिभाषित करने के लिए संरचनाओं (struct) के अंदर सामान्य प्रकार के मापदंडों का भी उपयोग कर सकते हैं:

struct KeyValuePair<K, V> {
    key: K,
    value: V,
}

fn main() {
    let pair = KeyValuePair {
        key: String::from("age"),
        value: 30,
    };
}

एक सामान्य संरचना के लिए impl ब्लॉक में, हमें impl कीवर्ड के तुरंत बाद टाइप पैरामीटर <T> घोषित करना होगा ताकि यह दर्शाया जा सके कि हम एक सामान्य संरचना पर तरीकों को लागू कर रहे हैं:

struct Container<T> {
    value: T,
}

impl<T> Container<T> {
    fn new(value: T) -> Self {
        Container { value }
    }

    fn value(&self) -> &T {
        &self.value
    }
}

खुद कोशिश करना

अभ्यास 1: बिंदु संरचना

व्यायाम 2: स्वैप के साथ टुपल को उलटना

अभ्यास 3: कंटेनर संरचना