Contexte et motivations
L’auteur développe avec Rust depuis plus de six ans, dont plus de quatre en contexte professionnel. Il explique que la différence fondamentale entre Rust et des langages comme JavaScript ou Python l’a contraint à repenser sa façon de structurer le code. Cette contrainte provient de la rigueur du système de types de Rust, qui impose des vérifications à la compilation plutôt qu’à l’exécution.
Types produit et types somme en Rust
Rust distingue clairement les types produit (structs) et les types somme (enums). L’exemple
struct Human {
first_name: String,
last_name: String,
} montre un produit où chaque champ existe indépendamment. En revanche, l’enum suivant représente une somme de variantes :enum Person {
Human { first_name: String, last_name: String },
Cat { name: String, cuteness: Cuteness }
}Le compilateur Rust oblige le développeur à gérer chaque variante via match, garantissant ainsi l’exhaustivité du traitement. Cette contrainte élimine les erreurs de logique liées aux cas non traités, un problème fréquent dans les langages sans types somme.
Dispatch statique vs dynamique
Dans les langages orientés objet, la polymorphie repose sur le dispatch dynamique via des interfaces ou l’héritage :
interface Person {
def do_one_thing()
def do_another_thing()
}
class Human implements Person { … }
class Cat implements Person { … }Rust propose deux alternatives : le dispatch dynamique explicite (via les trait objects) et le dispatch statique grâce aux génériques. L’exemple suivant illustre un groupe typé à la compilation :
struct Group {
// champs
}
let cat_group: Group = Group::new();Le compilateur refuse toute utilisation d’opérations non définies pour Cat, assurant une invariance statique sans surcharge d’exécution. Cette approche supprime le besoin d’une interface générique lorsque le domaine d’application est limité, réduisant la complexité et le coût de performance.
Implications sur la conception logicielle
Le passage de l’abstraction basée sur des interfaces à l’utilisation d’enums et de génériques modifie plusieurs pratiques : il élimine la surcharge de création d’interfaces inutiles, renforce la lisibilité du code grâce à des structures de données explicites, et améliore la sécurité en empêchant les erreurs de type à la compilation. Cependant, l’auteur note que dans des projets très extensibles, la création d’une interface reste pertinente pour respecter le principe ouvert/fermé. En somme, Rust ne supprime pas les abstractions orientées objet, mais il les rend optionnelles et plus coûteuses à justifier lorsqu’une simple enum suffit.