Generieken en functies

Met Generics kunt u flexibele, herbruikbare code schrijven, waarbij dubbele logica voor verschillende gegevenstypen wordt vermeden. In plaats van meerdere functies of structuren voor verschillende typen te definiëren (zoals i32, f64 of String), kunnen we een generieke typeparameter gebruiken, gewoonlijk weergegeven door de letter T.

De Rust-compiler beheert generieke codes met behulp van een proces dat monomorfisatie wordt genoemd: tijdens het compileren genereert het een kopie van de generieke code voor elk concreet type dat daadwerkelijk wordt gebruikt. Dit betekent dat er geen runtime-prestatieoverhead is.

Generieke functies

Om een ​​generieke functie te definiëren, voegen we de typeparameter <T> direct na de functienaam en vóór de argumentenlijst in:

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

In generieke functies kunnen we het generieke type T gebruiken voor zowel argumenttypen als retourneringstypen:

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

Generieke structuren

We kunnen ook generieke typeparameters binnen structuren (struct) gebruiken om flexibele velden te definiëren:

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

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

In een impl blok voor een generieke structuur moeten we de typeparameter <T> onmiddellijk na het sleutelwoord impl declareren om aan te geven dat we methoden implementeren op een generieke structuur:

struct Container<T> {
    value: T,
}

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

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

Probeer het zelf

Oefening 1: De puntenstructuur

Oefening 2: Een tupel omkeren met swap

Oefening 3: De containerstructuur