Méthodes sur les Enums

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

Tout comme les structures, les énumérations peuvent avoir des méthodes définies dans des blocs impl. Cela vous permet d'attacher un comportement directement à votre type d'énumération, facilitant ainsi le travail avec différentes variantes via une interface unifiée.

Voici comment ajouter une méthode à l'énumération Message de la leçon précédente :

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

impl Message {
    fn describe(&self) -> String {
        match self {
            Message::Quit => String::from("Quit signal"),
            Message::Move { x, y } => format!("Move to ({}, {})", x, y),
            Message::Write(text) => format!("Message: {}", text),
        }
    }
}

Le bloc impl Message fonctionne exactement de la même manière que pour les structures. La méthode prend &self pour accéder à l'instance de l'énumération. À l'intérieur de la méthode, vous utilisez match pour déterminer à quelle variante vous avez affaire et renvoyer le résultat approprié.

L'appel de la méthode est identique quelle que soit la variante que vous possédez :

fn main() {
    let m1 = Message::Quit;
    let m2 = Message::Move { x: 10, y: 20 };
    
    println!("{}", m1.describe());  // Signal d'arrêt
    println!("{}", m2.describe());  // Déplacement vers (10, 20)
}

Ce modèle est puissant car l'appelant n'a pas besoin de savoir quelle variante il possède — il appelle simplement la méthode, et l'enum gère le reste en interne. Le comportement change en fonction de la variante, mais l'interface reste cohérente.

Défi

Facile

Construisons un système de feux de signalisation qui utilise une énumération avec des méthodes pour décrire l'état actuel du signal. Chaque couleur de feu portera des informations sur sa durée, et une méthode fournira une description lisible par l'homme.

Vous allez créer deux fichiers pour organiser votre code :

traffic.rs : Définissez une énumération publique TrafficLight avec trois variantes :
- Red — contient un u32 représentant les secondes d'attente
- Yellow — contient un u32 représentant les secondes d'attente
- Green — contient un u32 représentant les secondes pour passer
Ensuite, implémentez une méthode status qui retourne une String décrivant le feu. Utilisez match à l'intérieur de la méthode pour gérer chaque variante et inclure la durée dans le message.
main.rs : Importez votre module traffic, créez des instances de chaque variante de feu, et appelez la méthode status sur chacune pour afficher les descriptions.

La méthode status doit retourner des messages dans ces formats exacts :

Pour Red : Stop for {seconds} seconds
Pour Yellow : Caution for {seconds} seconds
Pour Green : Go for {seconds} seconds

Votre sortie doit afficher le statut de chaque feu sur sa propre ligne :

Stop for {seconds} seconds
Caution for {seconds} seconds
Go for {seconds} seconds

Par exemple, avec un feu rouge de 30 secondes, un jaune de 5 secondes et un vert de 25 secondes, la sortie serait :

Stop for 30 seconds
Caution for 5 seconds
Go for 25 seconds

Vous recevrez trois entrées : la durée du feu rouge, la durée du feu jaune et la durée du feu vert.

Aide-mémoire

Les enums peuvent avoir des méthodes définies dans des blocs impl, tout comme les structs :

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

impl Message {
    fn describe(&self) -> String {
        match self {
            Message::Quit => String::from("Quit signal"),
            Message::Move { x, y } => format!("Move to ({}, {})", x, y),
            Message::Write(text) => format!("Message: {}", text),
        }
    }
}

Les méthodes prennent &self pour accéder à l'instance de l'enum et utilisent match pour gérer les différentes variantes :

let m1 = Message::Quit;
let m2 = Message::Move { x: 10, y: 20 };

println!("{}", m1.describe());  // Signal de sortie
println!("{}", m2.describe());  // Déplacement vers (10, 20)

L'appelant utilise la même interface quelle que soit la variante — l'enum gère le comportement en interne selon la variante dont il s'agit.

Essayez vous-même

mod traffic;

use traffic::TrafficLight;

fn main() {
    // Lire les entrées pour les durées
    let mut red_input = String::new();
    std::io::stdin().read_line(&mut red_input).expect("Failed to read line");
    let red_duration: u32 = red_input.trim().parse().expect("Invalid number");

    let mut yellow_input = String::new();
    std::io::stdin().read_line(&mut yellow_input).expect("Failed to read line");
    let yellow_duration: u32 = yellow_input.trim().parse().expect("Invalid number");

    let mut green_input = String::new();
    std::io::stdin().read_line(&mut green_input).expect("Failed to read line");
    let green_duration: u32 = green_input.trim().parse().expect("Invalid number");

    // TODO: Créer des instances de chaque variante de TrafficLight avec les durées saisies

    // TODO: Appeler la méthode status sur chaque feu et afficher le résultat
}