Chaînage de méthodes

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

Jusqu'à présent, nos méthodes mutables ont modifié la structure et n'ont rien renvoyé. Mais que se passe-t-il si nous voulons appeler plusieurs méthodes à la suite sur la même instance ? En renvoyant une référence à self, nous permettons le chaînage de méthodes—un modèle où plusieurs appels de méthodes s'enchaînent dans une seule expression.

La clé est de faire en sorte que vos méthodes &mut self retournent &mut Self :

struct Config {
    debug: bool,
    timeout: u32,
}

impl Config {
    fn new() -> Config {
        Config { debug: false, timeout: 30 }
    }
    
    fn set_debug(&mut self, value: bool) -> &mut Self {
        self.debug = value;
        self
    }
    
    fn set_timeout(&mut self, seconds: u32) -> &mut Self {
        self.timeout = seconds;
        self
    }
}

Chaque méthode modifie la structure, puis retourne self—une référence mutable vers la même instance. Cela permet à l'appel de méthode suivant de continuer à travailler dessus immédiatement :

fn main() {
    let mut config = Config::new();
    
    config.set_debug(true).set_timeout(60);
    
    println!("Debug: {}, Timeout: {}", config.debug, config.timeout);
    // Sortie : Debug: true, Timeout: 60
}

Au lieu d'écrire trois instructions distinctes, nous configurons tout sur une seule ligne fluide. Ce modèle de type « builder » est particulièrement utile lors de la configuration d'objets comportant de nombreux paramètres optionnels, ce qui rend votre code plus concis et lisible.

Défi

Facile

Créez une structure TextStyle avec trois champs : bold (bool), italic (bool), et size (u32).

Ajoutez un bloc d'implémentation pour TextStyle avec les éléments suivants :

new — une fonction associée qui retourne un TextStyle avec bold défini sur false, italic sur false, et size sur 12
set_bold — prend &mut self et une valeur bool, définit le champ bold, et retourne &mut Self pour le chaînage
set_italic — prend &mut self et une valeur bool, définit le champ italic, et retourne &mut Self pour le chaînage
set_size — prend &mut self et une valeur u32, définit le champ size, et retourne &mut Self pour le chaînage

Vous recevrez trois entrées :

Première ligne : paramètre bold (true ou false)
Deuxième ligne : paramètre italic (true ou false)
Troisième ligne : taille de police (u32)

Créez un TextStyle mutable en utilisant new, puis utilisez le chaînage de méthodes pour appliquer les trois paramètres en une seule expression. Affichez l'état final dans le format indiqué ci-dessous.

Format de sortie attendu :

Bold: {bold}, Italic: {italic}, Size: {size}

Aide-mémoire

Les méthodes qui prennent &mut self peuvent retourner &mut Self pour permettre le chaînage de méthodes :

impl Config {
    fn set_debug(&mut self, value: bool) -> &mut Self {
        self.debug = value;
        self
    }
    
    fn set_timeout(&mut self, seconds: u32) -> &mut Self {
        self.timeout = seconds;
        self
    }
}

Cela permet plusieurs appels de méthodes dans une seule expression :

let mut config = Config::new();
config.set_debug(true).set_timeout(60);

Chaque méthode modifie la structure et retourne une référence mutable vers la même instance, permettant à la méthode suivante de continuer à travailler dessus immédiatement.

Essayez vous-même

use std::io;

// TODO : Définir la structure TextStyle ici


// TODO : Ajouter le bloc d'implémentation pour TextStyle avec :
// - la fonction associée new()
// - la méthode set_bold()
// - la méthode set_italic()
// - la méthode set_size()


fn main() {
    let mut input = String::new();
    
    // Lire le paramètre de gras
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let bold: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Lire le paramètre d'italique
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let italic: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Lire le paramètre de taille
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let size: u32 = input.trim().parse().expect("Invalid u32");
    
    // TODO : Créer un TextStyle mutable en utilisant new(), puis utiliser le chaînage de méthodes
    // pour appliquer les trois paramètres en une seule expression
    
    
    // TODO : Afficher le résultat au format : Bold: {bold}, Italic: {italic}, Size: {size}
    
}