జెనరిక్స్ మరియు విధులు

జెనరిక్స్ విభిన్న డేటా రకాల కోసం తర్కం యొక్క నకిలీని నివారించడం ద్వారా సౌకర్యవంతమైన, పునర్వినియోగ కోడ్‌ను వ్రాయడానికి మిమ్మల్ని అనుమతిస్తుంది. వివిధ రకాలైన (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: కంటైనర్ నిర్మాణం