Traits avancés

pub trait Iterator {
    type Item;                                   // type associé : choisi par chaque implémentation
    fn next(&mut self) -> Option<Self::Item>;
}

struct Compteur { n: u32 }

impl Iterator for Compteur {
    type Item = u32;                             // ici, Item vaut u32
    fn next(&mut self) -> Option<u32> {
        self.n += 1;
        (self.n <= 3).then_some(self.n)
    }
}

Un type associé est un « trou » dans le trait, rempli une fois par chaque implémentation.

fn somme<I>(it: I) -> u32
where
    I: Iterator<Item = u32>,          // contrainte sur le type associé
{
    it.sum()
}

fn afficher_tout<I>(it: I)
where
    I: Iterator,
    I::Item: std::fmt::Debug,         // contrainte sur le type associé lui-même
{
    for x in it {
        println!("{x:?}");
    }
}

trait Depot {
    type Cle: std::hash::Hash + Eq + Clone;      // toute implémentation doit choisir une clé hachable
    type Valeur;
    type Erreur: std::error::Error;

    fn lire(&self, cle: &Self::Cle) -> Result<Option<Self::Valeur>, Self::Erreur>;
}

// 1. Paramètre générique : un type peut implémenter le trait PLUSIEURS fois
trait ConvertirEn<T> {
    fn convertir(&self) -> T;
}

struct Metres(f64);
impl ConvertirEn<f64> for Metres { fn convertir(&self) -> f64 { self.0 } }
impl ConvertirEn<String> for Metres { fn convertir(&self) -> String { format!("{} m", self.0) } }

// 2. Type associé : UNE seule implémentation par type
trait Contenant {
    type Element;
    fn premier(&self) -> Option<&Self::Element>;
}

struct Pile(Vec<i32>);
impl Contenant for Pile {
    type Element = i32;
    fn premier(&self) -> Option<&i32> { self.0.first() }
}

let m = Metres(3.0);
// let x = m.convertir();               // ERREUR : vers quel type ?
let x: f64 = m.convertir();             // l'appelant doit préciser
let y = ConvertirEn::<String>::convertir(&m);

let p = Pile(vec![1]);
let z = p.premier();                     // aucune ambiguïté : un seul Element possible

String peut être construite depuis &str, char, Box<str>... : From<T> est générique. Un itérateur ne produit qu'une sorte d'élément : Item est associé.

pub trait Add<Rhs = Self> {        // par défaut, on additionne deux valeurs du même type
    type Output;
    fn add(self, rhs: Rhs) -> Self::Output;
}

use std::ops::{Add, AddAssign, Neg, Sub};

#[derive(Debug, Clone, Copy, PartialEq)]
struct Vecteur { x: f64, y: f64 }

impl Add for Vecteur {
    type Output = Vecteur;
    fn add(self, o: Vecteur) -> Vecteur { Vecteur { x: self.x + o.x, y: self.y + o.y } }
}

impl Sub for Vecteur {
    type Output = Vecteur;
    fn sub(self, o: Vecteur) -> Vecteur { Vecteur { x: self.x - o.x, y: self.y - o.y } }
}

impl Neg for Vecteur {
    type Output = Vecteur;
    fn neg(self) -> Vecteur { Vecteur { x: -self.x, y: -self.y } }
}

impl AddAssign for Vecteur {
    fn add_assign(&mut self, o: Vecteur) { self.x += o.x; self.y += o.y; }
}

let a = Vecteur { x: 1.0, y: 2.0 };
let b = Vecteur { x: 3.0, y: 4.0 };
let mut c = a + b - Vecteur { x: 1.0, y: 1.0 };
c += a;
let d = -c;

use std::ops::Mul;

impl Mul<f64> for Vecteur {                  // Vecteur * f64
    type Output = Vecteur;
    fn mul(self, k: f64) -> Vecteur { Vecteur { x: self.x * k, y: self.y * k } }
}

impl Mul<Vecteur> for f64 {                  // f64 * Vecteur : permis, Vecteur est local
    type Output = Vecteur;
    fn mul(self, v: Vecteur) -> Vecteur { v * self }
}

let e = a * 2.0;
let f = 2.0 * a;

use std::ops::Add;

#[derive(Debug, Clone)]
struct Grand(Vec<u64>);                          // pas Copy : a + b consommerait a et b

impl Add<&Grand> for &Grand {
    type Output = Grand;
    fn add(self, o: &Grand) -> Grand {
        Grand(self.0.iter().zip(&o.0).map(|(x, y)| x + y).collect())
    }
}

let a = Grand(vec![1, 2]);
let b = Grand(vec![3, 4]);
let c = &a + &b;                                 // a et b restent utilisables

use std::ops::{Index, IndexMut};

struct Grille { largeur: usize, cases: Vec<char> }

impl Index<(usize, usize)> for Grille {
    type Output = char;
    fn index(&self, (x, y): (usize, usize)) -> &char {
        &self.cases[y * self.largeur + x]
    }
}

impl IndexMut<(usize, usize)> for Grille {
    fn index_mut(&mut self, (x, y): (usize, usize)) -> &mut char {
        &mut self.cases[y * self.largeur + x]
    }
}

let mut g = Grille { largeur: 3, cases: vec!['.'; 9] };
g[(1, 1)] = '#';
println!("{}", g[(1, 1)]);

use std::fmt::Display;

trait Etiquette: Display {                       // tout type Etiquette doit aussi être Display
    fn etiquette(&self) -> String {
        format!("[{}]", self)                    // permis : Display est garanti
    }
}

struct Code(u32);
impl Display for Code {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "C{}", self.0) }
}
impl Etiquette for Code {}

// struct Brut;
// impl Etiquette for Brut {}                    // ERREUR : Brut n'implémente pas Display

trait Entite: Clone + std::fmt::Debug + Send + Sync + 'static {
    fn id(&self) -> u64;
}

Un supertrait n'est pas de l'héritage : Entite n'hérite d'aucun code, elle exige que ses implémenteurs aient aussi Clone, Debug, etc. Les méthodes par défaut d'Entite peuvent alors s'en servir.

// 1. Supertrait : la contrainte vaut partout où le trait est utilisé
trait Affichable1: Display { fn titre(&self) -> String; }

// 2. Contrainte locale : seule cette fonction exige Display
trait Affichable2 { fn titre(&self) -> String; }
fn montrer<T: Affichable2 + Display>(x: &T) { println!("{x} {}", x.titre()); }

Mets un supertrait quand le trait n'a pas de sens sans l'autre (une erreur sans Display, un trait object partagé sans Send + Sync). Sinon, une contrainte locale laisse plus de liberté.

trait Crier {
    fn crier(&self) -> String;
}

impl<T: std::fmt::Display> Crier for T {          // pour TOUS les types affichables
    fn crier(&self) -> String {
        self.to_string().to_uppercase()
    }
}

println!("{}", "bonjour".crier());
println!("{}", 42.crier());

// impl<T: Display + ?Sized> ToString for T          // .to_string() sur tout Display
// impl<T, U: From<T>> Into<U> for T                  // Into gratuit pour tout From
// impl<T: ?Sized> Borrow<T> for T
// impl<I: Iterator> IntoIterator for I               // un itérateur est utilisable dans for

trait Valide {}                                   // « cette valeur a été vérifiée »

struct Brut(String);
struct Verifie(String);
impl Valide for Verifie {}

fn enregistrer<T: Valide>(_v: T) {}

// enregistrer(Brut("x".into()));                 // ERREUR : Brut n'est pas Valide
enregistrer(Verifie("x".into()));

mod prive {
    pub trait Sceau {}                            // public, mais dans un module privé : inaccessible
}

pub trait Format: prive::Sceau {                  // le supertrait est impossible à implémenter ailleurs
    fn extension(&self) -> &'static str;
}

pub struct Json;
pub struct Csv;

impl prive::Sceau for Json {}
impl prive::Sceau for Csv {}
impl Format for Json { fn extension(&self) -> &'static str { "json" } }
impl Format for Csv { fn extension(&self) -> &'static str { "csv" } }

Hors de la crate, on peut utiliser Format (fn f(x: impl Format)), mais pas l'implémenter : prive::Sceau n'est pas nommable.

// 1. Vérification à l'exécution : un booléen et une erreur possible
struct Connexion1 { authentifiee: bool }
impl Connexion1 {
    fn envoyer(&self, _msg: &str) -> Result<(), String> {
        if !self.authentifiee {
            return Err("non authentifiée".into());
        }
        Ok(())
    }
}

// 2. Vérification à la compilation : deux types d'état
use std::marker::PhantomData;

struct Anonyme;
struct Authentifiee;

struct Connexion<Etat> { _etat: PhantomData<Etat> }

impl Connexion<Anonyme> {
    fn new() -> Self { Connexion { _etat: PhantomData } }
    fn login(self, _mdp: &str) -> Connexion<Authentifiee> { Connexion { _etat: PhantomData } }
}

impl Connexion<Authentifiee> {
    fn envoyer(&self, _msg: &str) {}              // n'existe qu'une fois connecté
}

fn main() {
    let c = Connexion::new();
    // c.envoyer("x");                            // ERREUR : pas de méthode envoyer pour Connexion<Anonyme>
    let c = c.login("secret");
    c.envoyer("x");
}

#[diagnostic::on_unimplemented(
    message = "`{Self}` ne peut pas être enregistré : il n'a pas été validé",
    label = "valeur non validée",
    note = "passe d'abord la valeur à `valider()`"
)]
trait Valide {}

// runique/src/app/builder/mod.rs (extrait, généré par une macro)
#[diagnostic::on_unimplemented(
    message = "`routes()` has already been called on this builder",
    label = "a second `routes()` would replace every route of the first",
    note = "build a single `Router` (merge or nest the others into it) and pass it once"
)]
pub trait RoutesUnset: sealed::Sealed {}

trait Stockage {
    async fn lire(&self, cle: &str) -> Option<String>;
}

struct Memoire(std::collections::HashMap<String, String>);

impl Stockage for Memoire {
    async fn lire(&self, cle: &str) -> Option<String> {
        self.0.get(cle).cloned()
    }
}

async fn utiliser<S: Stockage>(s: &S) {
    let _ = s.lire("a").await;
    // tokio::spawn(async move { s.lire("a").await });   // le futur renvoyé est-il Send ? inconnu
}

Le futur renvoyé par lire n'a pas de contrainte Send : il ne peut pas être passé à tokio::spawn dans du code générique, et le trait n'est pas utilisable en dyn Stockage.

use std::future::Future;
use std::pin::Pin;

// 1. async fn natif : simple, pas de dyn, pas de garantie Send
trait Stockage1 {
    async fn lire(&self, cle: &str) -> Option<String>;
}

// 2. Renvoyer impl Future + Send : garantit Send, toujours pas de dyn
trait Stockage2 {
    fn lire(&self, cle: &str) -> impl Future<Output = Option<String>> + Send;
}

// 3. Futur en Box : compatible dyn et Send, une allocation par appel
trait Stockage3: Send + Sync {
    fn lire<'a>(&'a self, cle: &'a str) -> Pin<Box<dyn Future<Output = Option<String>> + Send + 'a>>;
}

La crate async-trait génère la forme 3 à partir d'une écriture async fn :

#[async_trait::async_trait]
trait Stockage4: Send + Sync {
    async fn lire(&self, cle: &str) -> Option<String>;
}

Runique utilise async-trait pour FormField (forms/base.rs) : les champs d'un formulaire sont des Box<dyn FormField> (voir box-dynamiques) et certaines de leurs méthodes sont asynchrones, ce qui exige la forme 3. Dans db/adb.rs, il sert à implémenter ConnectionTrait et TransactionTrait, des traits de SeaORM déclarés eux-mêmes avec async-trait.

trait Animal { fn nom() -> String; }

struct Chien;
impl Chien { fn nom() -> String { "Médor".into() } }
impl Animal for Chien { fn nom() -> String { "chien".into() } }

fn main() {
    Chien::nom();                     // "Médor" : la fonction propre au type
    // Animal::nom();                 // ERREUR : pour quel type ?
    <Chien as Animal>::nom();         // "chien"
}

fn description<T: Animal>() -> String {
    <T as Animal>::nom()              // ou simplement T::nom() si aucune ambiguïté
}

fn premier<I: Iterator>(mut it: I) -> Option<<I as Iterator>::Item> {
    it.next()
}

<I as Iterator>::Item s'écrit d'habitude I::Item ; la forme complète sert quand I implémente deux traits ayant chacun un type Item.

trait Forme { fn aire(&self) -> f64; }

impl<T: Forme + ?Sized> Forme for &T {
    fn aire(&self) -> f64 { (**self).aire() }
}

impl<T: Forme + ?Sized> Forme for Box<T> {
    fn aire(&self) -> f64 { (**self).aire() }
}

fn total(formes: &[impl Forme]) -> f64 {
    formes.iter().map(|f| f.aire()).sum()
}

Avec ces deux implémentations, total accepte un Vec<Carre>, un Vec<&Carre> et un Vec<Box<dyn Forme>>.

impl<T: Forme> Forme for Vec<T> {
    fn aire(&self) -> f64 { self.iter().map(|f| f.aire()).sum() }   // une liste de formes est une forme
}

Possible parce que Forme est local (règle de l'orphelin, voir traits-basics).

trait Preteur {
    type Vue<'a> where Self: 'a;                   // le type dépend de la durée de l'emprunt
    fn voir<'a>(&'a self) -> Self::Vue<'a>;
}

struct Texte(String);

impl Preteur for Texte {
    type Vue<'a> = &'a str;
    fn voir<'a>(&'a self) -> &'a str { &self.0 }
}

// 1. Enum : les sortes de tâches sont connues
enum Tache { Email(String), Nettoyage }
fn executer1(t: &Tache) {
    match t {
        Tache::Email(a) => println!("email à {a}"),
        Tache::Nettoyage => println!("nettoyage"),
    }
}

// 2. Trait + générique : chaque file contient une seule sorte
trait Executable { fn executer(&self); }
struct File<T: Executable> { taches: Vec<T> }
impl<T: Executable> File<T> {
    fn tout(&self) { self.taches.iter().for_each(|t| t.executer()); }
}

// 3. Trait object : sortes mélangées, extensible par l'utilisateur
struct FileDyn { taches: Vec<Box<dyn Executable + Send>> }

// 4. Trait scellé + trait object : sortes mélangées, liste FERMÉE garantie
mod scelle { pub trait Sceau {} }
pub trait TacheInterne: scelle::Sceau + Send { fn executer(&self); }

trait T { type A; fn f(&self) -> Self::A; }          // type associé
fn g<I: Iterator<Item = u32>>(i: I)                    // contrainte sur type associé
trait Add<Rhs = Self> { type Output; .. }              // paramètre par défaut
impl Add for X { type Output = X; fn add(self, o: X) -> X { .. } }
impl Index<usize> for X { type Output = Y; fn index(&self, i: usize) -> &Y { .. } }
trait A: Display + Send {}                             // supertraits
impl<T: Display> MonTrait for T {}                     // implémentation globale
trait Marqueur {}                                      // trait marqueur
mod prive { pub trait Sceau {} } pub trait S: prive::Sceau {}   // trait scellé
struct X<Etat> { _e: PhantomData<Etat> }               // typestate
#[diagnostic::on_unimplemented(message = "..")]
trait A { async fn f(&self); }                         // async natif
fn f(&self) -> impl Future<Output = T> + Send;        // async + Send
<Type as Trait>::fonction()                            // syntaxe complète
type Vue<'a> where Self: 'a;                           // GAT