Syntaxe des contraintes de trait

Fait partie de la section Object Oriented Programming du Journey Rust de Coddy. Leçon 40 sur 61.

Jusqu’à présent, tu as appris à définir des traits et à les implémenter pour des structures. Tu as également travaillé avec les génériques pour écrire du code flexible. Il est maintenant temps de combiner ces concepts : utiliser des traits pour restreindre les types qu’une fonction générique peut accept.

Considérons une generic function qui doit call une méthode spécifique sur son paramètre. Sans aucune contrainte, Rust ne peut pas garantir que le type T possède cette méthode :

fn print_info<T>(item: T) {
    println!("{}", item.summarize());  // Erreur ! T pourrait ne pas avoir summarize()
}

La solution est une contrainte de trait. En ajoutant : TraitName après le paramètre générique, vous indiquez à Rust que T doit implémenter ce trait :

trait Summary {
    fn summarize(&self) -> String;
}

fn print_info<T: Summary>(item: T) {
    println!("{}", item.summarize());  // Maintenant Rust sait que cette méthode existe
}

La syntaxe <T: Summary> se lit comme suit : « T est any type qui implements Summary. » Désormais, la function n’accepte que les types qui have le comportement requis. Si vous essayez de transmettre un type qui n’implémente pas Summary, le compilateur le rejettera avec une erreur claire.

Ce pattern est puissant, car il vous permet d’écrire du code generic qui a toujours accès à des fonctionnalités spécifiques. Votre function reste flexible, elle fonctionne avec any type, mais uniquement avec les types qui fournissent le comportement dont vous avez besoin.

Défi

Facile

Construisons un système de notification qui utilise des contraintes de traits afin de garantir que seuls les messages correctement formatés puissent être envoyés ! Vous allez créer une fonction générique qui accepte tout type implémentant un trait spécifique, afin de montrer comment les contraintes de traits limitent les paramètres génériques.

Vous allez organiser votre code dans deux fichiers :

notification.rs : définissez un trait Notify public avec une méthode appelée message qui prend &self et returns une String. Créez ensuite deux structures publiques qui implémentent ce trait :
- Email : avec un champ subject public (String). Sa méthode message doit renvoyer Email: {subject}
- SMS : avec un champ content public (String). Sa méthode message doit renvoyer SMS: {content}
Enfin, créez une fonction générique publique appelée send_notification qui accepte tout type T implémentant le trait Notify. Cette fonction doit afficher le résultat de l'appel de message() sur l'item.
main.rs : ajoutez votre module de notification et utilisez les entrées fournies pour créer une instance de Email et une instance de SMS. Appelez send_notification avec chacune d'elles afin de montrer que votre fonction générique fonctionne avec tout type qui implémente Notify.

L'idée essentielle ici est que send_notification ne connaît pas le type concret qu'il reçoit. Il sait seulement que le type peut produire un message. La contrainte de trait T: Notify garantit cette capacité.

Votre sortie doit montrer que les deux notifications sont envoyées :

Email: {subject}
SMS: {content}

Par exemple, avec les entrées Meeting Tomorrow et On my way! :

Email: Meeting Tomorrow
SMS: On my way!

Vous recevrez deux entrées : le sujet de l'e-mail et le contenu du SMS.

Essayez vous-même

mod notification;

use notification::{Email, SMS, send_notification};

fn main() {
    // Lire les entrées
    let mut subject = String::new();
    std::io::stdin().read_line(&mut subject).expect("Failed to read line");
    let subject = subject.trim().to_string();
    
    let mut content = String::new();
    std::io::stdin().read_line(&mut content).expect("Failed to read line");
    let content = content.trim().to_string();
    
    // TODO: Créer une instance Email avec le subject
    
    // TODO: Créer une instance SMS avec le content
    
    // TODO: Appeler send_notification avec l'email
    
    // TODO: Appeler send_notification avec le sms
}