Génériques et fonctions

Les generics (types génériques) permettent d'écrire du code flexible et réutilisable, en évitant la duplication de logique pour différents types de données. Au lieu de définir plusieurs fonctions ou structures pour des types différents (tels que i32, f64 ou String), nous pouvons utiliser un paramètre de type générique, conventionnellement désigné par la lettre T.

Le compilateur Rust gère les generics à l'aide d'un processus appelé monomorphisation : lors de la compilation, le compilateur génère une copie du code générique pour chaque type concret avec lequel il est réellement utilisé. De cette façon, il n'y a aucune surcharge de performance à l'exécution.

Fonctions Génériques

Pour définir une fonction générique, nous insérons le paramètre de type <T> juste après le nom de la fonction et avant la liste des paramètres :

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

Dans les fonctions génériques, nous pouvons utiliser le type générique T à la fois pour les types des arguments et pour le type de retour :

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

Structures Génériques

Nous pouvons également utiliser des paramètres de type générique à l'intérieur des structures de données (struct) pour définir des champs flexibles :

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

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

Dans le bloc impl pour une struct générique, nous devons déclarer le paramètre de type <T> juste après le mot-clé impl pour indiquer que nous implémentons des méthodes sur une structure générique :

struct Container<T> {
    value: T,
}

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

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

À toi de jouer

Exercice 1 : La structure Point

Exercice 2 : Inversion d'un Tuple avec swap

Exercice 3 : La structure Container