Qu'est-ce qu'un Trait ?

Fait partie de la section Object Oriented Programming du Journey Rust de Coddy — leçon 29 sur 61.

Les génériques vous permettent d'écrire du code qui fonctionne avec n'importe quel type, mais parfois, vous devez garantir qu'un type peut faire quelque chose de spécifique. C'est là que les traits interviennent.

Un trait définit un ensemble de méthodes qu'un type doit implémenter. Considérez cela comme un contrat : tout type qui « signe » ce contrat promet de fournir le comportement spécifié. Si vous avez utilisé des interfaces dans d'autres langages, les traits servent un objectif similaire.

Voici comment définir un trait :

trait Describable {
    fn describe(&self) -> String;
}

Le mot-clé trait introduit le trait, suivi de son nom. À l'intérieur des accolades, vous déclarez les signatures de méthode — seulement le nom, les paramètres et le type de retour, sans corps. Le point-virgule après la signature indique qu'il s'agit d'une exigence, et non d'une implémentation.

Ce trait Describable indique : « Tout type qui m'implémente doit fournir une méthode describe qui prend une référence à lui-même et renvoie une String. » Le trait ne se soucie pas de comment la méthode fonctionne — cela dépend de chaque type qui l'implémente.

Les traits deviennent puissants lorsque plusieurs types différents implémentent le même trait. Un Book, une Car et une Person pourraient tous être Describable, chacun fournissant sa propre description unique. Le trait garantit qu'ils partagent tous cette capacité commune.

Défi

Facile

Définissons votre premier trait ! Un trait établit un contrat — une promesse que tout type l'implémentant fournira un comportement spécifique. Vous allez créer un trait Summarizable que différents types pourront implémenter pour fournir un résumé d'eux-mêmes.

Vous organiserez votre code sur deux fichiers :

summary.rs : Définissez un trait public appelé Summarizable avec une seule signature de méthode : summarize(&self) -> String. Rappelez-vous, dans une définition de trait, vous déclarez seulement la signature de la méthode avec un point-virgule — pas de corps. Cela indique à Rust que "tout type qui implémente ce trait doit fournir une méthode summarize qui retourne un String."
main.rs : Importez votre module summary et affichez un message confirmant que votre trait est défini. Comme nous n'avons pas encore appris comment implémenter des traits (c'est la prochaine leçon !), vous allez simplement vérifier que votre trait compile correctement.

Dans votre fichier principal, affichez le message suivant pour confirmer que la définition de votre trait est valide :

Summarizable trait defined successfully!

Ce défi se concentre uniquement sur la syntaxe de définition des traits — le mot-clé trait, le nom du trait et la déclaration des signatures de méthodes sans implémentations. Dans la prochaine leçon, vous apprendrez comment faire en sorte que des structs implémentent ce trait !

Aide-mémoire

Un trait définit un ensemble de méthodes qu'un type doit implémenter. Il agit comme un contrat qui garantit qu'un type fournit un comportement spécifique.

Pour définir un trait, utilisez le mot-clé trait suivi du nom du trait et des signatures de méthode :

trait Describable {
    fn describe(&self) -> String;
}

Les signatures de méthode dans les traits incluent le nom, les paramètres et le type de retour, mais pas de corps. Le point-virgule indique qu'il s'agit d'une exigence pour les types qui l'implémentent.

Plusieurs types différents peuvent implémenter le même trait, chacun fournissant sa propre implémentation des méthodes requises.

Essayez vous-même

mod summary;

fn main() {
    // TODO: Afficher le message de confirmation que le trait est défini
    // Résultat attendu: "Summarizable trait defined successfully!"
    
}