Devoluciones anticipadas

En el ejemplo anterior, manejamos explícitamente los errores usando combinadores. Otra forma de lidiar con este análisis de caso es usar una combinación de declaraciones de match y devoluciones anticipadas.

Es decir, podemos simplemente dejar de ejecutar la función y devolver el error si ocurre uno. Para algunos, esta forma de código puede ser más fácil de leer y escribir. Considera esta versión del ejemplo anterior, reescrito utilizando devoluciones anticipadas:

use std::num::ParseIntError;

fn multiplica(primer_num_str: &str, segundo_num_str: &str) -> Result<i32, ParseIntError> {
    let primer_num = match primer_num_str.parse::<i32>() {
        Ok(primer_num)  => primer_num,
        Err(e) => return Err(e),
    };

    let segundo_num = match segundo_num_str.parse::<i32>() {
        Ok(segundo_num)  => segundo_num,
        Err(e) => return Err(e),
    };

    Ok(primer_num * segundo_num)
}

fn imprime(result: Result<i32, ParseIntError>) {
    match result {
        Ok(n)  => println!("n is {}", n),
        Err(e) => println!("Error: {}", e),
    }
}

fn main() {
    imprime(multiplica("10", "2"));
    imprime(multiplica("t", "2"));
}

En este punto, hemos aprendido a manejar errores explícitamente usando combinadores y devoluciones anticipadas. Si bien generalmente queremos evitar el pánico, manejar explícitamente todos nuestros errores es engorroso.

En la siguiente sección, presentaremos ? para los casos en los que simplemente necesitamos unwrap sin inducir posiblemente el panic.