Generice și funcții

Generice vă permit să scrieți cod flexibil, reutilizabil, evitând duplicarea logicii pentru diferite tipuri de date. În loc să definim mai multe funcții sau structuri pentru diferite tipuri (cum ar fi i32, f64 sau String), putem folosi un parametru de tip generic, reprezentat în mod convențional prin litera T.

Compilatorul Rust gestionează generice folosind un proces numit monomorfizare: în timpul compilării, generează o copie a codului generic pentru fiecare tip de beton care este efectiv utilizat. Aceasta înseamnă că nu există nicio suprasarcină de performanță la timpul de rulare.

Funcții generice

Pentru a defini o funcție generică, inserăm parametrul de tip <T> imediat după numele funcției și înaintea listei de argumente:

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

În funcțiile generice, putem folosi tipul generic T atât pentru tipurile de argument, cât și pentru tipurile de returnare:

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

Structuri generice

De asemenea, putem folosi parametrii de tip generic în interiorul structurilor (struct) pentru a defini câmpuri flexibile:

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

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

Într-un bloc impl pentru o structură generică, trebuie să declarăm parametrul de tip <T> imediat după cuvântul cheie impl pentru a indica că implementăm metode pe o structură generică:

struct Container<T> {
    value: T,
}

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

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

Încercați-l singur

Exercițiul 1: Structura punctuală

Exercițiul 2: Inversarea unui tuplu cu swap

Exercițiul 3: Structura containerului