Traits — Les bases

Un trait est un contrat : il définit un ensemble de méthodes qu'un type doit implémenter. C'est l'équivalent des interfaces dans d'autres langages, avec des fonctionnalités en plus.

Les traits permettent de :

• Écrire du code générique réutilisable
• Définir des interfaces sans héritage
• Garantir des comportements à la compilation

Un trait déclare des signatures de méthodes. Les types qui l'implémentent doivent fournir le corps.

Un trait peut aussi définir des méthodes associées (sans &self) :

La syntaxe est impl NomTrait for NomType.

Une implémentation par défaut s'applique automatiquement si le type ne la redéfinit pas. Elle peut appeler d'autres méthodes du même trait.

impl Trait est un raccourci syntaxique pour les trait bounds. Il rend le code plus lisible.

impl Trait en position de retour cache le type concret tout en gardant le dispatch statique.

// Le type exact de l'itérateur est caché
fn nombres_pairs(limite: u32) -> impl Iterator<Item = u32> {
    (0..limite).filter(|n| n % 2 == 0)
}

// Utile pour retourner des closures
fn multiplicateur(facteur: i32) -> impl Fn(i32) -> i32 {
    move |x| x * facteur
}

let doubler = multiplicateur(2);
println!("{}", doubler(5)); // 10

Limite : avec impl Trait en retour, tous les chemins de code doivent retourner le même type concret. Pour retourner des types différents, utilisez Box<dyn Trait>.

// Ceci ne compile PAS — deux types concrets différents
// fn animal(chien: bool) -> impl Animal {
//     if chien { Chien } else { Chat }
// }

// Solution : Box<dyn Trait>
fn animal(chien: bool) -> Box<dyn Animal> {
    if chien { Box::new(Chien) } else { Box::new(Chat) }
}

L'attribut #[derive(...)] génère automatiquement des implémentations de traits standard.

Permet l'affichage avec {:?} et {:#?} (pretty-print).

#[derive(Debug)]
struct Utilisateur {
    nom: String,
    age: u32,
    actif: bool,
}

let u = Utilisateur { nom: "Alice".to_string(), age: 30, actif: true };

println!("{:?}", u);   // Utilisateur { nom: "Alice", age: 30, actif: true }
println!("{:#?}", u);  // version indenté multi-ligne

Hash est nécessaire pour utiliser un type comme clé de HashMap ou dans un HashSet. Il requiert PartialEq (et recommande Eq).

use std::collections::HashMap;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
struct CleComposee {
    categorie: String,
    identifiant: u32,
}

let mut map: HashMap<CleComposee, String> = HashMap::new();

map.insert(
    CleComposee { categorie: "utilisateur".to_string(), identifiant: 42 },
    "Alice".to_string(),
);

let cle = CleComposee { categorie: "utilisateur".to_string(), identifiant: 42 };
println!("{:?}", map.get(&cle)); // Some("Alice")

Un type peut implémenter autant de traits que nécessaire.

use std::fmt;

#[derive(Clone)]
struct Vecteur2D {
    x: f64,
    y: f64,
}

impl Vecteur2D {
    fn norme(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }
}

impl fmt::Display for Vecteur2D {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

impl fmt::Debug for Vecteur2D {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Vecteur2D {{ x: {}, y: {} }}", self.x, self.y)
    }
}

impl PartialEq for Vecteur2D {
    fn eq(&self, other: &Self) -> bool {
        (self.x - other.x).abs() < f64::EPSILON
            && (self.y - other.y).abs() < f64::EPSILON
    }
}

impl std::ops::Add for Vecteur2D {
    type Output = Vecteur2D;

    fn add(self, other: Vecteur2D) -> Vecteur2D {
        Vecteur2D {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

Rust impose une contrainte : pour implémenter un trait sur un type, au moins l'un des deux doit être défini dans le crate courant.

// OK — MonType est dans notre crate
impl Display for MonType { ... }

// OK — MonTrait est dans notre crate
impl MonTrait for String { ... }

// INTERDIT — ni Display ni Vec ne sont dans notre crate
// impl Display for Vec<i32> { ... }

Pour contourner cette règle, on utilise le newtype pattern :

// Wrapper local autour d'un type externe
struct MesNombres(Vec<i32>);

impl fmt::Display for MesNombres {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let s: Vec<String> = self.0.iter().map(|n| n.to_string()).collect();
        write!(f, "[{}]", s.join(", "))
    }
}

let liste = MesNombres(vec![1, 2, 3]);
println!("{liste}"); // [1, 2, 3]

Créez un trait Convertible avec une méthode en_chaine(&self) -> String et implémentez-le pour f64, une struct Temperature et une struct Couleur { r: u8, g: u8, b: u8 }.

trait Convertible {
    fn en_chaine(&self) -> String;
}

impl Convertible for f64 {
    fn en_chaine(&self) -> String {
        format!("{:.2}", self)
    }
}

struct Temperature {
    celsius: f64,
}

impl Convertible for Temperature {
    fn en_chaine(&self) -> String {
        format!("{:.1}°C", self.celsius)
    }
}

struct Couleur {
    r: u8,
    g: u8,
    b: u8,
}

impl Convertible for Couleur {
    fn en_chaine(&self) -> String {
        format!("#{:02X}{:02X}{:02X}", self.r, self.g, self.b)
    }
}

// Test
let t = Temperature { celsius: 36.6 };
let c = Couleur { r: 255, g: 128, b: 0 };
println!("{}", t.en_chaine()); // 36.6°C
println!("{}", c.en_chaine()); // #FF8000

Écrivez une fonction plus_grand générique qui fonctionne avec tout type comparable et affichable.

use std::fmt::Display;

fn plus_grand<T>(liste: &[T]) -> Option<&T>
where
    T: PartialOrd + Display,
{
    let mut max = liste.first()?;
    for item in liste.iter() {
        if item > max {
            max = item;
        }
    }
    Some(max)
}

let nombres = vec![34, 50, 25, 100, 65];
let lettres = vec!['y', 'm', 'a', 'q'];

println!("{:?}", plus_grand(&nombres)); // Some(100)
println!("{:?}", plus_grand(&lettres)); // Some('y')

Derives et leurs usages :

Points clés à retenir :