Traits & generics, ou le polymorphisme à coût zéro Traits & generics, or zero-cost polymorphism

Pas d'héritage. Un contrat que le type choisit d'honorer.No inheritance. A contract the type chooses to honor.

Les quatre premiers volumes portaient sur la sûreté ; celui-ci ouvre la réutilisation. La question change : comment écrire un comportement une seule fois et l'appliquer à des types différents ? Les langages à objets répondent par l'héritage — un type dérive d'un autre et récupère ses méthodes. Rust n'a pas d'héritage, et ce n'est pas un manque : c'est un choix. Le partage de comportement y passe par les traits — des contrats. Un trait déclare ce qu'un type doit savoir faire ; un type décide, par un bloc impl, d'honorer ce contrat. Une fonction générique n'exige alors plus un type précis, mais la preuve qu'il respecte le contrat. C'est le polymorphisme sans la hiérarchie.The first four volumes were about safety; this one opens reuse. The question shifts: how do you write a behavior once and apply it to different types? Object-oriented languages answer with inheritance — a type derives from another and inherits its methods. Rust has no inheritance, and that's not a lack: it's a choice. Behavior sharing goes through traits — contracts. A trait declares what a type must know how to do; a type decides, via an impl block, to honor that contract. A generic function then no longer demands a precise type, but proof that it respects the contract. It's polymorphism without the hierarchy.

// Un trait : un CONTRAT de comportement, que chaque type choisit d'honorer
trait Surface {
    fn aire(&self) -> f64;          // « quiconque est Surface sait donner son aire »
}

impl Surface for Cercle {           // le cercle décide d'honorer le contrat
    fn aire(&self) -> f64 { std::f64::consts::PI * self.r * self.r }
}
impl Surface for Rectangle {
    fn aire(&self) -> f64 { self.l * self.h }
}

// une fonction générique exige le contrat, pas un type précis :
fn afficher_aire<F: Surface>(forme: &F) {   // « tout F qui est Surface »
    println!("aire = {}", forme.aire());
}

Écrit une fois, valable pour mille types — et pourtant aussi rapide que copié-collé.Written once, valid for a thousand types — yet as fast as copy-paste.

Sans abstraction, partager une logique entre types se paie en copier-coller : une fonction max par type comparable, identiques au type de l'élément près. C'est le terreau du bug qu'on corrige à deux endroits sur trois. Le générique borné par un trait écrit la logique une fois, pour tout type qui honore le contrat. La surprise, pour qui vient d'un langage à objets, n'est pas la concision — c'est que ça ne coûte rien à l'exécution. On s'attend à payer une indirection, un test de type au runtime, comme avec une méthode virtuelle. Il n'en est rien : un générique Rust n'existe pas à l'exécution sous forme générique. Le compilateur le transforme. Le chapitre suivant montre comment.Without abstraction, sharing logic between types costs copy-paste: one max per comparable type, identical down to the element type. It's the breeding ground for the bug you fix in two places out of three. The trait-bounded generic writes the logic once, for any type that honors the contract. The surprise, for someone from an object-oriented language, isn't the concision — it's that it costs nothing at runtime. You expect to pay an indirection, a runtime type check, as with a virtual method. Not so: a Rust generic doesn't exist at runtime in generic form. The compiler transforms it. The next chapter shows how.

// Sans abstraction : une copie de la logique par type concret
fn max_i32(liste: &[i32]) -> Option<&i32> {
    let mut m = liste.first()?;
    for x in liste { if x > m { m = x; } }
    Some(m)
}
fn max_f64(liste: &[f64]) -> Option<&f64> { /* ... le même corps, mot pour mot ... */ }
fn max_str(liste: &[&str]) -> Option<&&str> { /* ... encore une fois ... */ }

// trois fonctions identiques à l'élément près. chaque nouveau type
// comparable = un copier-coller de plus, et un bug à corriger en trois endroits.

Trois corps de fonction rigoureusement identiques, séparés par le seul type de l'élément. Le coût n'est pas qu'esthétique : une correction (gérer la liste vide, changer la condition) doit être reportée partout, et l'oubli d'un seul endroit est un bug silencieux. Chaque nouveau type comparable rouvre le copier-coller. C'est l'absence d'abstraction qui se paie — non pas en lenteur, mais en maintenance et en risque.Three strictly identical function bodies, separated only by the element type. The cost isn't merely aesthetic: a fix (handle the empty list, change the condition) must be carried everywhere, and missing a single spot is a silent bug. Each new comparable type reopens the copy-paste. It's the absence of abstraction being paid for — not in slowness, but in maintenance and risk.

La monomorphisation : le générique disparaît, remplacé par des copies concrètes.Monomorphization: the generic vanishes, replaced by concrete copies.

Voici le secret du « coût zéro ». Quand tu appelles une fonction générique avec un type donné, le compilateur en fabrique une version spécialisée pour ce type — une copie où T est remplacé par i32, par &str, par ce que tu veux. C'est la monomorphisation : transformer un code poly-morphe (plusieurs formes) en plusieurs codes mono-morphes (une forme chacun). À l'exécution, il n'y a plus de générique du tout : juste des fonctions concrètes, appelées directement, sans indirection ni recherche de méthode. La performance est exactement celle du code écrit à la main pour chaque type. Le polymorphisme a été entièrement résolu à la compilation.Here's the 'zero-cost' secret. When you call a generic function with a given type, the compiler builds a specialized version for that type — a copy where T is replaced by i32, by &str, by whatever. That's monomorphization: turning poly-morphic code (many forms) into several mono-morphic codes (one form each). At runtime, there's no generic at all: just concrete functions, called directly, with no indirection or method lookup. Performance is exactly that of hand-written code for each type. The polymorphism was entirely resolved at compile time.

// Ce qu'on écrit — une seule fonction générique
fn afficher<T: std::fmt::Display>(x: T) { println!("{x}"); }

afficher(42);        // T = i32
afficher("salut");   // T = &str

// Ce que le compilateur GÉNÈRE (monomorphisation) — une copie par type utilisé
fn afficher_i32(x: i32)  { println!("{x}"); }     // version spécialisée pour i32
fn afficher_str(x: &str) { println!("{x}"); }     // version spécialisée pour &str
// les appels pointent vers la bonne copie. plus aucun « générique » à l'exécution :
// que des fonctions concrètes, appelées en direct, comme si tu les avais écrites.

// Trois écritures de bornes de trait — à choisir selon la lisibilité

fn somme<T: Add<Output = T> + Copy>(a: T, b: T) -> T { a + b }   // (1) bornes inline

fn fusion<T>(a: &[T], b: &[T]) -> Vec<T>                         // (2) clause where :
where                                                            //     respire quand les
    T: Clone + PartialOrd,                                       //     bornes s'accumulent
{ /* ... */ }

fn afficher(x: impl Display) { println!("{x}"); }               // (3) impl Trait, le sucre

La généricité gratuite : un coût de lecture et de binaire pour une réutilisation qui n'existe pas.Gratuitous genericity: a reading and binary cost for reuse that doesn't exist.

Une fois la puissance des generics comprise, la tentation est de tout abstraire. Chaque fonction reçoit des paramètres de type, chaque argument devient « un quelconque T borné ». Mais l'abstraction a un prix, et c'est le même refrain que le sur-typage du Vol 3 : du boilerplate de bornes, des signatures illisibles, des messages d'erreur qui triplent de longueur, et — propre aux generics — une monomorphisation qui gonfle le binaire et ralentit la compilation. Quand un paramètre générique n'est jamais instancié qu'avec un seul type, il n'abstrait rien : il déguise un type concret en variable, et fait payer à tout le monde une flexibilité que personne n'utilise.Once you grasp generics' power, the temptation is to abstract everything. Every function gets type parameters, every argument becomes 'some bounded T'. But abstraction has a price, and it's the same refrain as Vol 3's over-typing: bound boilerplate, unreadable signatures, error messages that triple in length, and — specific to generics — monomorphization that bloats the binary and slows compilation. When a generic parameter is only ever instantiated with one type, it abstracts nothing: it disguises a concrete type as a variable, and makes everyone pay for a flexibility no one uses.

// Tout générifier « au cas où » — abstraction sans réutilisation
fn enregistrer<T, W, S>(donnee: T, sortie: &mut W, serialiseur: S) -> Result<(), Err>
where
    T: Serialize + Clone + Debug + Send + Sync + 'static,
    W: Write + Seek,
    S: Serialiseur<T>,
{ /* ... appelé À UN SEUL endroit, avec un seul jeu de types ... */ }

// trois paramètres de type et six bornes pour un appel unique. la signature
// est illisible, les messages d'erreur monstrueux, et le binaire monomorphise
// un cas qui n'existe qu'une fois. de la généricité qui ne sert personne.

Cette signature exige un effort de lecture considérable — déchiffrer trois paramètres et leurs bornes — pour une fonction appelée une seule fois, avec des types fixes. La généricité n'y achète aucune réutilisation : elle ne fait qu'ajouter du bruit, allonger les diagnostics du compilateur, et générer une copie monomorphisée pour un cas unique. C'est la cérémonie du Vol 3 transposée aux types : de l'abstraction qui ne prévient ni ne permet rien.This signature demands considerable reading effort — decoding three parameters and their bounds — for a function called once, with fixed types. The genericity buys no reuse: it only adds noise, lengthens the compiler's diagnostics, and generates a monomorphized copy for a single case. It's Vol 3's ceremony transposed to types: abstraction that neither prevents nor enables anything.

// On fixe ce qui ne varie pas ; générique seulement là où ça réutilise
fn enregistrer(donnee: &Rapport, sortie: &mut File) -> Result<(), Err> {
    let bytes = serde_json::to_vec(donnee)?;   // types concrets : clairs, directs
    sortie.write_all(&bytes)?;
    Ok(())
}

// si DEMAIN un second type de donnée doit passer ici, alors — et seulement
// alors — on extrait un paramètre générique borné par le trait utile. la
// généricité se mérite par un besoin réel de réutilisation, pas par anticipation.

Des types concrets rendent la fonction immédiatement lisible : on voit ce qui entre, ce qui sort, sans déchiffrer de bornes. La généricité s'introduit le jour où un vrai second cas d'usage apparaît — pas par anticipation d'un besoin hypothétique. La règle est la même qu'au Vol 3 : la flexibilité est un coût, et on ne le dépense que là où une réutilisation réelle le rembourse.Concrete types make the function immediately readable: you see what goes in, what comes out, without decoding bounds. Genericity enters the day a real second use case appears — not by anticipating a hypothetical need. The rule is the same as Vol 3's: flexibility is a cost, spent only where real reuse repays it.