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.

Skills Graph

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.