Explorando el enum Result de Rust

Introducción

En este laboratorio, exploramos el enum Result en Rust, que nos permite expresar el éxito o el fracaso de una operación devolviendo ya sea Ok con un valor o Err con una explicación del fracaso.

Nota: Si el laboratorio no especifica un nombre de archivo, puede usar cualquier nombre de archivo que desee. Por ejemplo, puede usar main.rs, compilar y ejecutarlo con rustc main.rs &&./main.

Result

Hemos visto que el enum Option se puede usar como valor de retorno de funciones que pueden fallar, donde se puede devolver None para indicar el fracaso. Sin embargo, a veces es importante expresar por qué una operación falló. Para hacer esto tenemos el enum Result.

El enum Result<T, E> tiene dos variantes:

• Ok(value) que indica que la operación tuvo éxito y envuelve el value devuelto por la operación. (value tiene tipo T)
• Err(why), que indica que la operación falló y envuelve why, que (esperemos) explica la causa del fracaso. (why tiene tipo E)

mod checked {
    // "Errores" matemáticos que queremos capturar
    #[derive(Debug)]
    pub enum MathError {
        DivisionByZero,
        NonPositiveLogarithm,
        NegativeSquareRoot,
    }

    pub type MathResult = Result<f64, MathError>;

    pub fn div(x: f64, y: f64) -> MathResult {
        if y == 0.0 {
            // Esta operación `fallaría`, en lugar de eso, devolvemos la razón del
            // fracaso envuelta en `Err`
            Err(MathError::DivisionByZero)
        } else {
            // Esta operación es válida, devolvemos el resultado envuelto en `Ok`
            Ok(x / y)
        }
    }

    pub fn sqrt(x: f64) -> MathResult {
        if x < 0.0 {
            Err(MathError::NegativeSquareRoot)
        } else {
            Ok(x.sqrt())
        }
    }

    pub fn ln(x: f64) -> MathResult {
        if x <= 0.0 {
            Err(MathError::NonPositiveLogarithm)
        } else {
            Ok(x.ln())
        }
    }
}

// `op(x, y)` === `sqrt(ln(x / y))`
fn op(x: f64, y: f64) -> f64 {
    // ¡Este es un triángulo de coincidencias de tres niveles!
    match checked::div(x, y) {
        Err(why) => panic!("{:?}", why),
        Ok(ratio) => match checked::ln(ratio) {
            Err(why) => panic!("{:?}", why),
            Ok(ln) => match checked::sqrt(ln) {
                Err(why) => panic!("{:?}", why),
                Ok(sqrt) => sqrt,
            },
        },
    }
}

fn main() {
    // ¿Esto fallará?
    println!("{}", op(1.0, 10.0));
}

Resumen

¡Felicitaciones! Has completado el laboratorio de Result. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.