Uso de 'match' con 'Result'

Parte de la sección Logic & Flow del Journey de Rust de Coddy — lección 43 de 66.

Ahora que entiendes qué es un Result, aprendamos la forma más explícita y potente de manejar tanto los casos de éxito como los de error: usando una expresión match.

Al igual que con Option, match te obliga a manejar ambas variantes de un Result. Creas una rama para Ok para manejar el éxito, y otra rama para Err para manejar el error:

let result = divide(10, 2);

match result {
    Ok(value) => println!("Division successful: {}", value),
    Err(error) => println!("Division failed: {}", error),
}

Cuando el Result es Ok, el match extrae el valor exitoso y ejecuta el primer brazo. Cuando es Err, extrae la información del error y ejecuta el segundo brazo. Este patrón asegura que nunca ignores accidentalmente un posible error.

Desafío

Fácil

Recibirás dos entradas. La primera entrada es un número (como una cadena), y la segunda entrada es otro número (como una cadena). Crea una función que intente dividir el primer número por el segundo número y devuelva un Result<f64, &'static str>. Si el segundo número es cero, devuelve un Err con el mensaje "Division by zero". De lo contrario, devuelve Ok con el resultado de la división. Usa una expresión match para manejar tanto los casos Ok como Err e imprimir el mensaje apropiado.

Requerimientos:

Leer la primera entrada (dividendo) y eliminar los espacios en blanco
Convertir (parse) la primera entrada a f64
Leer la segunda entrada (divisor) y eliminar los espacios en blanco
Convertir (parse) la segunda entrada a f64
Crear una función que tome dos parámetros f64 y devuelva Result<f64, &'static str>
Dentro de la función, verificar si el divisor es 0.0:
- Si es así, devolver Err("Division by zero")
- Si no, devolver Ok(dividend / divisor)
Llamar a la función con los dos números procesados
Usar una expresión match para manejar el Result
En el brazo Ok(value), imprimir: Result: [value]
En el brazo Err(error), imprimir: Error: [error]

Entrada:

Primera línea: Un número que representa el dividendo (por ejemplo, 10.0)
Segunda línea: Un número que representa el divisor (por ejemplo, 2.0)

Salida:

Si la división es exitosa: Result: [result]
Si hay división por cero: Error: Division by zero

Hoja de referencia

Usa match para manejar tanto las variantes Ok como Err de un Result:

let result = divide(10, 2);

match result {
    Ok(value) => println!("Division successful: {}", value),
    Err(error) => println!("Division failed: {}", error),
}

La expresión match te obliga a manejar tanto los casos de éxito como los de error. Cuando el Result es Ok, extrae el valor exitoso y ejecuta el primer brazo. Cuando es Err, extrae la información del error y ejecuta el segundo brazo.

Pruébalo tú mismo

use std::io;

// TODO: Crea tu función de división aquí que devuelva Result<f64, &'static str>


fn main() {
    // Leer la primera entrada (dividendo)
    let mut dividend_input = String::new();
    io::stdin().read_line(&mut dividend_input).expect("Failed to read line");
    let dividend: f64 = dividend_input.trim().parse().expect("Invalid number");
    
    // Leer la segunda entrada (divisor)
    let mut divisor_input = String::new();
    io::stdin().read_line(&mut divisor_input).expect("Failed to read line");
    let divisor: f64 = divisor_input.trim().parse().expect("Invalid number");
    
    // TODO: Llama a tu función de división y usa match para manejar el Result
    // Imprime "Result: [value]" para el caso Ok
    // Imprime "Error: [error]" para el caso Err
}