Uso de 'match' con 'Result'

Parte de la sección Lógica y Flujo 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 cadena) y la segunda entrada es otro número (como cadena). Crea una función que intente dividir el primer número entre el segundo 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 gestionar los casos Ok y Err e imprimir el mensaje correspondiente.

Requisitos:

Lee la primera entrada (dividendo) y elimina los espacios en blanco
Analiza la primera entrada como f64
Lee la segunda entrada (divisor) y elimina los espacios en blanco
Analiza la segunda entrada como f64
Crea una función que reciba dos parámetros f64 y devuelva Result<f64, &'static str>
Dentro de la función, comprueba si el divisor es 0.0:
- Si es así, devuelve Err("Division by zero")
- Si no, devuelve Ok(dividend / divisor)
Llama a la función con los dos números analizados
Usa una expresión match para gestionar el Result
En la rama Ok(value), imprime: Result: [value]
En la rama Err(error), imprime: 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 tiene éxito: Result: [result]
Si se divide entre cero: Error: Division by zero

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
}