Rust by Example

map for Result

Panicking in the previous example's multiply does not make for robust code. Generally, we want to return the error to the caller so it can decide what is the right way to respond to errors.

We first need to know what kind of error type we are dealing with. To determine the Err type, we look to parse(), which is implemented with the FromStr trait for i32. As a result, the Err type is specified as ParseIntError.

In the example below, the straightforward match statement leads to code that is overall more cumbersome.

use std::num::ParseIntError;

// With the return type rewritten, we use pattern matching without `unwrap()`.

fn multiply(first_number_str: &str, second_number_str: &str) -> Result {

match first_number_str.parse::() {

Ok(first_number)  => {

match second_number_str.parse::() {

Ok(second_number)  => {

Ok(first_number * second_number)

},

Err(e) => Err(e),

}

},

Err(e) => Err(e),

}

}

fn print(result: Result) {

match result {

Ok(n)  => println!("n is {}", n),

Err(e) => println!("Error: {}", e),

}

}

fn main() {

// This still presents a reasonable answer.

let twenty = multiply("10", "2");

print(twenty);

// The following now provides a much more helpful error message.

let tt = multiply("t", "2");

print(tt);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Luckily, Option's map, and_then, and many other combinators are also implemented for Result. Result contains a complete listing.

use std::num::ParseIntError;

// As with `Option`, we can use combinators such as `map()`.

// This function is otherwise identical to the one above and reads:

// Modify n if the value is valid, otherwise pass on the error.

fn multiply(first_number_str: &str, second_number_str: &str) -> Result {

first_number_str.parse::().and_then(|first_number| {

second_number_str.parse::().map(|second_number| first_number * second_number)

})

}

fn print(result: Result) {

match result {

Ok(n)  => println!("n is {}", n),

Err(e) => println!("Error: {}", e),

}

}

fn main() {

// This still presents a reasonable answer.

let twenty = multiply("10", "2");

print(twenty);

// The following now provides a much more helpful error message.

let tt = multiply("t", "2");

print(tt);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX