How can I propagate the errors in Rust?

Question

Is there a nice way to propagate errors in Rust? E. g., I'd like to refactor the following code to avoid nested errors:

.for_each(|record| {
    match f1() {
        Ok(a1) => match f2() {
            Ok(a2) => match f3() {
                Ok(_) => {}
                Err(e) => {
                    eprintln!("Error: {}", e);
                }
            },
            Err(e) => {
                eprintln!("Error: {}", e);
            }
        },
        Err(e) => {
            eprintln!("Error: {}", e);
        }
    };
    Ok(())
})

The question is not a duplicate because I've got a for_each operator which complicates a situation for me. And when I put ? to f2 I actually receive the following error:

the trait `std::convert::From<std::io::Error>` is not implemented for `grpcio::error::Error`

Possible duplicate of [What is this question mark operator about?](https://stackoverflow.com/questions/42917566/what-is-this-question-mark-operator-about) — hellow, Jan 24 '19 at 09:14
@hellow thanks for the suggestion, but I can't understand how I use `?` together with `for_each`. — H. Desane, Jan 24 '19 at 09:24
Unfortunately, you cannot use functional style loops + error propagation because you're inside a closure. — Boiethios, Jan 24 '19 at 09:33
@Boiethios Actually we can't tell that you cannot use it in closure, it is a closure that doesn't return `Result`.(If we are talking about `iterators` in rust core), That's why we can't use error propagating. — Ömer Erden, Jan 24 '19 at 09:39
@ÖmerErden they return `Result/String/String, io:Error>`, but the error type is the same. — H. Desane, Jan 24 '19 at 09:41

score 3 · Accepted Answer · answered Jan 24 '19 at 09:44

You can chain your functions in the success scenario with and_then and map their errors with map_err.

Like here you can chain them:

let result = f1().and_then(|_| {
    f2().and_then(|_| {
        f3().and_then(|_| {
            println!("All functions are succeed");
            Ok(())
        })
    })
});

Here you will have the result variable if the error occurs.

Then you can match this error with if let Err(error) statement like following:

if let Err(error) = result {
    println!("Problem occurred: {:?}", error);
};

There is also possibility to throw your error to upper levels with try! macro or ? operator like following:

fn throw_error() -> Result<String, MyError> {
    let string_val = "will not be returned".to_string();

    Err(MyError::thrownError)?;
    Ok(string_val)
}

Here you can test and play a little bit more to understand the concepts.

How can I propagate the errors in Rust?

1 Answers1