Concatenamento di metodi

Fa parte della sezione Programmazione orientata agli oggetti del percorso Rust di Coddy. Lezione 6 di 61.

Finora, i nostri metodi mutabili hanno modificato la struct e non hanno restituito nulla. Ma cosa succede se vogliamo chiamare diversi metodi in successione sulla stessa istanza? Restituendo un riferimento a self, abilitiamo il concatenamento dei metodi: uno schema in cui più chiamate di metodo si susseguono in un'unica espressione.

La chiave è fare in modo che i tuoi metodi &mut self restituiscano &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
    }
}

Ogni metodo modifica la struct e poi restituisce self: un riferimento mutabile alla stessa istanza. Questo permette alla chiamata al metodo successiva di continuare subito a operare su di essa:

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

Invece di scrivere tre istruzioni separate, configuriamo tutto in un'unica riga fluida. Questo schema «builder» è particolarmente utile quando si configurano oggetti con molte impostazioni facoltative, rendendo il codice più conciso e leggibile.

Sfida

Facile

Crea una struttura TextStyle con tre campi: bold (bool), italic (bool) e size (u32).

Aggiungi un blocco di implementazione per TextStyle con quanto segue:

new: una funzione associata che restituisce un TextStyle con bold impostato su false, italic impostato su false e size impostato su 12
set_bold: accetta &mut self e un valore bool, imposta il campo bold e restituisce &mut Self per consentire il concatenamento
set_italic: accetta &mut self e un valore bool, imposta il campo italic e restituisce &mut Self per consentire il concatenamento
set_size: accetta &mut self e un valore u32, imposta il campo size e restituisce &mut Self per consentire il concatenamento

Riceverai tre input:

Prima riga: impostazione bold (true o false)
Seconda riga: impostazione italic (true o false)
Terza riga: dimensione del carattere (u32)

Crea un TextStyle mutabile usando new, poi usa il concatenamento dei metodi per applicare tutte e tre le impostazioni in un'unica espressione. Stampa lo stato finale nel formato mostrato qui sotto.

Formato dell'output previsto:

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

Provalo tu

use std::io;

// TODO: Definisci qui la struct TextStyle


// TODO: Aggiungi il blocco di implementazione per TextStyle con:
// - funzione associata new()
// - metodo set_bold()
// - metodo set_italic()
// - metodo set_size()


fn main() {
    let mut input = String::new();
    
    // Leggi l'impostazione del grassetto
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let bold: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Leggi l'impostazione del corsivo
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let italic: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Leggi l'impostazione della dimensione
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let size: u32 = input.trim().parse().expect("Invalid u32");
    
    // TODO: Crea un TextStyle mutabile usando new(), poi concatena i metodi
    // per applicare tutte e tre le impostazioni in un'unica espressione
    
    
    // TODO: Stampa il risultato nel formato: Bold: {bold}, Italic: {italic}, Size: {size}
    
}