Explorando o Tipo Enumerado Result do Rust

Introdução

Neste laboratório, exploramos o tipo enumerado Result em Rust, que nos permite expressar o sucesso ou falha de uma operação, retornando Ok com um valor ou Err com uma explicação da falha.

Nota: Se o laboratório não especificar um nome de arquivo, você pode usar qualquer nome de arquivo que desejar. Por exemplo, você pode usar main.rs, compilar e executar com rustc main.rs && ./main.

Result

Vimos que o tipo enumerado Option pode ser usado como valor de retorno de funções que podem falhar, onde None pode ser retornado para indicar falha. No entanto, às vezes é importante expressar por que uma operação falhou. Para isso, temos o tipo enumerado Result.

O tipo enumerado Result<T, E> possui duas variantes:

• Ok(valor), que indica que a operação teve sucesso e encapsula o valor retornado pela operação. (valor tem tipo T)
• Err(motivo), que indica que a operação falhou e encapsula motivo, que (esperançosamente) explica a causa da falha. (motivo tem tipo E)

mod checked {
    // "Erros" 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 operação falharia; em vez disso, vamos retornar o motivo da
            // falha encapsulado em `Err`
            Err(MathError::DivisionByZero)
        } else {
            // Esta operação é válida; vamos retornar o resultado encapsulado em `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 {
    // Esta é uma pirâmide de correspondência de três níveis!
    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() {
    // Esta operação falhará?
    println!("{}", op(1.0, 10.0));
}

Resumo

Parabéns! Você concluiu o laboratório Result. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.