Coincidencia de variantes de datos

Parte de la sección Object Oriented Programming del Journey de Rust de Coddy. Lección 16 de 61.

En la lección anterior, usaste match dentro de los métodos de enum para manejar diferentes variantes. Ahora centrémonos en cómo match extrae realmente los datos almacenados dentro de esas variantes: una técnica llamada desestructuración.

Cuando haces match con una variante de enum que contiene datos, puedes vincular esos datos a variables directamente en el patrón:

enum Event {
    Click { x: i32, y: i32 },
    KeyPress(char),
    Resize(u32, u32),
}

fn handle_event(event: Event) {
    match event {
        Event::Click { x, y } => {
            println!("Clicked at ({}, {})", x, y);
        }
        Event::KeyPress(key) => {
            println!("Key pressed: {}", key);
        }
        Event::Resize(width, height) => {
            println!("Resized to {}x{}", width, height);
        }
    }
}

Cada brazo extrae los datos de forma diferente según la estructura de la variante. Para las variantes similares a estructuras, usas { field_name } para extraer campos named. Para las variantes de tupla, usas variables posicionales como (width, height).

Los nombres de variables que eliges pasan a estar disponibles dentro de esa rama de match. Esto es potente porque, al mismo tiempo, compruebas qué variante tienes y obtienes acceso a su carga útil.

El compilador garantiza que handle cada variante, y los valores extraídos están listos para usarse de inmediato: no se necesitan steps adicionales.

Desafío

Fácil

Construirás un procesador de comandos que gestione distintos tipos de comandos de usuario. Cada comando transporta datos diferentes, y tu procesador utilizará la coincidencia de patrones para extraer esos datos y producir respuestas apropiadas.

Crearás dos archivos para organizar tu código:

command.rs: Define un Command enum public con tres variantes:
- Say: holds un único mensaje String (sintaxis de tupla)
- Move: holds campos named: direction (String) y steps (u32)
- Calculate: holds dos valores i32 que representan los números que se sumarán (sintaxis de tupla)
Después implementa un método execute que utilice match para destructure cada variante y return un String que describa la acción realizada.
main.rs: Incorpora tu módulo de comandos, crea una instancia de cada variante de comando usando los inputs proporcionados y llama al método execute en cada una para imprimir los resultados.

Tu método execute debe destructure cada variante para acceder a sus datos y return mensajes con estos formatos exactos:

Para Say: Saying: {message}
Para Move: Moving {steps} steps {direction}
Para Calculate: {a} + {b} = {sum}

Tu salida debe mostrar el resultado de cada comando en su propia línea:

Saying: {message}
Moving {steps} steps {direction}
{a} + {b} = {sum}

Por ejemplo, con un mensaje de Say "Hello world", un movimiento de 5 steps en dirección "north" y un cálculo de 10 y 25, la salida sería:

Saying: Hello world
Moving 5 steps north
10 + 25 = 35

Recibirás cinco inputs: el mensaje de Say, la direction, el número de steps y los dos números que se calcularán.

Pruébalo tú mismo

mod command;

use command::Command;

fn main() {
    // Leer entradas
    let mut say_message = String::new();
    std::io::stdin().read_line(&mut say_message).expect("Failed to read line");
    let say_message = say_message.trim().to_string();

    let mut direction = String::new();
    std::io::stdin().read_line(&mut direction).expect("Failed to read line");
    let direction = direction.trim().to_string();

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

    let mut num1_input = String::new();
    std::io::stdin().read_line(&mut num1_input).expect("Failed to read line");
    let num1: i32 = num1_input.trim().parse().expect("Failed to parse num1");

    let mut num2_input = String::new();
    std::io::stdin().read_line(&mut num2_input).expect("Failed to read line");
    let num2: i32 = num2_input.trim().parse().expect("Failed to parse num2");

    // TODO: Crea un comando Say usando say_message y ejecútalo
    
    // TODO: Crea un comando Move usando direction y steps, y ejecútalo
    
    // TODO: Crea un comando Calculate usando num1 y num2, y ejecútalo
    
    // TODO: Imprime los resultados de cada ejecución de comando
}