Implémentations par défaut

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

Jusqu’à présent, chaque méthode de trait que nous avons définie n’était qu’une signature : une exigence sans corps. Mais que se passe-t-il si la plupart des types implémentant un trait utilisent la même logique ? Rust vous permet de fournir une implémentation par défaut directement dans la définition du trait.

Au lieu de terminer la signature de la méthode par un point-virgule, vous ajoutez un corps :

trait Greet {
    fn greet(&self) -> String {
        String::from("Hello there!")
    }
}

Désormais, tout type qui implémente Greet obtient automatiquement cette method, sans écrire de code dans le bloc impl :

struct Guest;

impl Greet for Guest {}

let visitor = Guest;
println!("{}", visitor.greet());  // Bonjour !

Le empty impl Greet for Guest {} est valide, car le trait fournit déjà le comportement. Le struct « adhère » simplement au trait et reçoit gratuitement la méthode default.

Ce modèle est utile lorsque vous souhaitez définir un comportement partagé qui fonctionne dans la plupart des cas. Les types qui ont besoin de quelque chose de différent peuvent remplacer le comportement default (ce que vous apprendrez ensuite), tandis que les types qui se satisfont du comportement standard n’ont pas besoin de se répéter.

Défi

Facile

Explorons la puissance des default implementations en construisant un système de notification ! Tu vas créer un trait qui fournit un comportement standard prêt à l'emploi, afin que les types puissent l'adopter sans écrire de code répétitif.

Tu vas organiser ton code sur trois fichiers :

notifiable.rs : définis un trait Notifiable public avec une méthode notify(&self) -> String qui possède une default implementation. La valeur par défaut doit retourner "You have a new notification!". Tout type qui implémente ce trait recevra automatiquement ce comportement sans avoir besoin de rien écrire dans son impl block.
alerts.rs : crée deux unit structs publics simples qui implémentent ton trait :
- EmailAlert : implémente Notifiable avec un impl block vide (utilise la valeur par défaut)
- SystemAlert : implémente également Notifiable avec un impl block vide (utilise la valeur par défaut)
Les deux structs recevront automatiquement le message de notification par défaut sans que tu aies à écrire le corps d'une quelconque méthode !
main.rs : rassemble tes modules et montre comment les deux types d'alerte partagent le même comportement par défaut. Crée des instances des deux structs et appelle leurs méthodes notify.

Dans ton fichier principal, crée un EmailAlert et un SystemAlert, puis affiche leurs notifications sur des lignes séparées.

Ta sortie doit être :

You have a new notification!
You have a new notification!

Remarque comme les deux types produisent une sortie identique : c'est toute la beauté des default implementations ! Aucun des deux structs n'a eu besoin d'écrire du code pour la méthode notify, et pourtant tous deux disposent d'un comportement de notification pleinement fonctionnel. Dans la prochaine leçon, tu apprendras à remplacer ces valeurs par défaut lorsqu'un type a besoin d'un comportement personnalisé.

Essayez vous-même

mod notifiable;
mod alerts;

use notifiable::Notifiable;
use alerts::{EmailAlert, SystemAlert};

fn main() {
    // TODO: Créer une instance de EmailAlert
    
    // TODO: Créer une instance de SystemAlert
    
    // TODO: Print the notification from EmailAlert
    
    // TODO: Print the notification from SystemAlert
}