ஜெனரிக்ஸ் மற்றும் செயல்பாடுகள்

ஜெனரிக்ஸ் பல்வேறு தரவு வகைகளுக்கான தர்க்கத்தின் நகல்களைத் தவிர்த்து, நெகிழ்வான, மீண்டும் பயன்படுத்தக்கூடிய குறியீட்டை எழுத உங்களை அனுமதிக்கிறது. வெவ்வேறு வகைகளுக்கு (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: கொள்கலன் அமைப்பு