Simplificando o Tratamento de Erros com o Operador Rust

Introdução

Neste laboratório, o operador ? é apresentado como uma forma de tornar o código mais limpo ao encadear resultados. É usado no final de uma expressão que retorna um Result e simplifica o código, lidando automaticamente com os ramos Err e Ok. O exemplo fornecido demonstra como usar o operador ? em Rust para lidar com várias operações matemáticas e seus potenciais erros.

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.

`?`

Encadear resultados usando match pode ficar bastante desordenado; felizmente, o operador ? pode ser usado para tornar as coisas mais organizadas novamente. ? é usado no final de uma expressão que retorna um Result e é equivalente a uma expressão match, onde o ramo Err(err) se expande para um return Err(From::from(err)) precoce, e o ramo Ok(ok) se expande para uma expressão ok.

mod checked {
    #[derive(Debug)]
    enum MathError {
        DivisionByZero,
        NonPositiveLogarithm,
        NegativeSquareRoot,
    }

    type MathResult = Result<f64, MathError>;

    fn div(x: f64, y: f64) -> MathResult {
        if y == 0.0 {
            Err(MathError::DivisionByZero)
        } else {
            Ok(x / y)
        }
    }

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

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

    // Função intermediária
    fn op_(x: f64, y: f64) -> MathResult {
        // Se `div` "falhar", então `DivisionByZero` será "retornado"
        let ratio = div(x, y)?;

        // Se `ln` "falhar", então `NonPositiveLogarithm` será "retornado"
        let ln = ln(ratio)?;

        sqrt(ln)
    }

    pub fn op(x: f64, y: f64) {
        match op_(x, y) {
            Err(why) => panic!("{}", match why {
                MathError::NonPositiveLogarithm
                    => "logaritmo de número não positivo",
                MathError::DivisionByZero
                    => "divisão por zero",
                MathError::NegativeSquareRoot
                    => "raiz quadrada de número negativo",
            }),
            Ok(value) => println!("{}", value),
        }
    }
}

fn main() {
    checked::op(1.0, 10.0);
}

Certifique-se de verificar a documentação, pois existem muitos métodos para mapear/compor Result.

Operador Rust Simplifica o Tratamento de Erros

Introdução

`?`

Resumo