Encadenamiento de Métodos

Parte de la sección Programación Orientada a Objetos del Journey de Rust de Coddy. Lección 6 de 61.

Hasta ahora, nuestros métodos mutable han modificado la estructura y no han devuelto nada. Pero ¿qué ocurre si queremos llamar a varios métodos seguidos en la misma instancia? Al devolver una referencia a self, habilitamos el encadenamiento de métodos: un patrón en el que varias llamadas a métodos fluyen juntas en una sola expression.

La clave es hacer que tus métodos &mut self devuelvan &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
    }
}

Cada método modifica la estructura y después devuelve self: una referencia mutable a la misma instancia. Esto permite que la siguiente llamada al método continúe trabajando con ella inmediatamente:

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

En lugar de escribir tres instrucciones separadas, configuramos todo en una sola línea fluida. Este patrón de «estilo constructor» es especialmente útil al configurar objetos con muchos ajustes opcionales, ya que hace que tu código sea más conciso y legible.

Desafío

Fácil

Crea una estructura TextStyle con tres campos: bold (bool), italic (bool) y size (u32).

Añade un bloque de implementación para TextStyle con lo siguiente:

new: una función asociada que devuelve un TextStyle con bold establecido en false, italic establecido en false y size establecido en 12
set_bold: toma &mut self y un valor bool, establece el campo bold y devuelve &mut Self para permitir el encadenamiento
set_italic: toma &mut self y un valor bool, establece el campo italic y devuelve &mut Self para permitir el encadenamiento
set_size: toma &mut self y un valor u32, establece el campo size y devuelve &mut Self para permitir el encadenamiento

Recibirás tres entradas:

Primera línea: configuración de negrita (true o false)
Segunda línea: configuración de cursiva (true o false)
Tercera línea: tamaño de fuente (u32)

Crea un TextStyle mutable usando new y, después, usa el encadenamiento de métodos para aplicar las tres configuraciones en una sola expresión. Imprime el estado final en el formato que se muestra a continuación.

Formato de salida esperado:

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

Pruébalo tú mismo

use std::io;

// TODO: Define la struct TextStyle aquí


// TODO: Añade el bloque de implementación para TextStyle con:
// - función asociada new()
// - método set_bold()
// - método set_italic()
// - método set_size()


fn main() {
    let mut input = String::new();
    
    // Leer configuración bold
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let bold: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Leer configuración italic
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let italic: bool = input.trim().parse().expect("Invalid bool");
    input.clear();
    
    // Leer configuración size
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let size: u32 = input.trim().parse().expect("Invalid u32");
    
    // TODO: Crea un TextStyle mutable usando new(), luego usa el encadenamiento de métodos
    // para aplicar las tres configuraciones en una sola expresión
    
    
    // TODO: Imprime el resultado en el formato: Bold: {bold}, Italic: {italic}, Size: {size}
    
}