Rust
जेनेरिक्स

घोषणा

// Generic types are declared using the <T> annotation

struct GenericType<T> {
    pub item: T
}

enum QualityChecked<T> {
    Excellent(T),
    Good(T),
    // enum fields can be generics too
    Mediocre { product: T }
}

प्रारंभ

// explicit type declaration
let some_value: Option<u32> = Some(13);

// implicit type declaration
let some_other_value = Some(66);

कई प्रकार के पैरामीटर

जेनरिक प्रकार में एक से अधिक प्रकार के पैरामीटर हो सकते हैं, जैसे। Result इस तरह परिभाषित किया गया है:

pub enum Result<T, E> {
    Ok(T),
    Err(E),
}

बंधे जेनेरिक प्रकार

// Only accept T and U generic types that also implement Debug
fn print_objects<T: Debug, U: Debug>(a: T, b: U) {
    println!("A: {:?} B: {:?}", a, b);
}

print_objects(13, 44);
// or annotated explicitly
print_objects::<usize, u16>(13, 44);

सीमा में सभी प्रकार के उपयोग शामिल होने चाहिए। जोड़ std::ops::Add द्वारा किया जाता है std::ops::Add विशेषता, जिसमें इनपुट और आउटपुट पैरामीटर स्वयं होते हैं। where T: std::ops::Add<u32,Output=U> कहता है कि T को u32 Add संभव है, और इसके अलावा U टाइप करना होगा।

fn try_add_one<T, U>(input_value: T) -> Result<U, String> 
    where T: std::ops::Add<u32,Output=U> 
{
    return Ok(input_value + 1);
}

Sized बाउंड डिफ़ॉल्ट रूप से निहित है। ?Sized के लिए बाध्य है और साथ ही अनवधि प्रकार की अनुमति देता है।

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

जेनेरिक फ़ंक्शंस उनके कुछ या सभी तर्कों को मानकीकृत करने की अनुमति देते हैं।

fn convert_values<T, U>(input_value: T) -> Result<U, String> {
  // Try and convert the value.
  // Actual code will require bounds on the types T, U to be able to do something with them.
}

यदि कंपाइलर टाइप पैरामीटर का अनुमान नहीं लगा सकता है तो इसे कॉल पर मैन्युअल रूप से आपूर्ति की जा सकती है:

let result: Result<u32, String> = convert_value::<f64, u32>(13.5);