Other uses of ?

Notice in the previous example that our immediate reaction to calling
parse is to map the error from a library error into a boxed
error:

  1. .and_then(|s| s.parse::<i32>()
  2.     .map_err(|e| e.into())

Since this is a simple and common operation, it would be convenient if it
could be elided. Alas, because and_then is not sufficiently flexible, it
cannot. However, we can instead use ?.

? was previously explained as either unwrap or return Err(err).
This is only mostly true. It actually means unwrap or
return Err(From::from(err)). Since From::from is a conversion utility
between different types, this means that if you ? where the error is
convertible to the return type, it will convert automatically.

Here, we rewrite the previous example using ?. As a result, the
map_err will go away when From::from is implemented for our error type:

  1. use std::error;
  2. use std::fmt;
  3. use std::num::ParseIntError;
  5. // Change the alias to `Box<error::Error>`.
  6. type Result<T> = std::result::Result<T, Box<error::Error>>;
  8. #[derive(Debug)]
  9. struct EmptyVec;
  11. impl fmt::Display for EmptyVec {
  12.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  13.         write!(f, "invalid first item to double")
  14.     }
  15. }
  17. impl error::Error for EmptyVec {
  18.     fn description(&self) -> &str {
  19.         "invalid first item to double"
  20.     }
  22.     fn cause(&self) -> Option<&error::Error> {
  23.         // Generic error, underlying cause isn't tracked.
  24.         None
  25.     }
  26. }
  28. // The same structure as before but rather than chain all `Results`
  29. // and `Options` along, we `?` to get the inner value out immediately.
  30. fn double_first(vec: Vec<&str>) -> Result<i32> {
  31.     let first = vec.first().ok_or(EmptyVec)?;
  32.     let parsed = first.parse::<i32>()?;
  33.     Ok(2 * parsed)
  34. }
  36. fn print(result: Result<i32>) {
  37.     match result {
  38.         Ok(n)  => println!("The first doubled is {}", n),
  39.         Err(e) => println!("Error: {}", e),
  40.     }
  41. }
  43. fn main() {
  44.     let numbers = vec!["42", "93", "18"];
  45.     let empty = vec![];
  46.     let strings = vec!["tofu", "93", "18"];
  48.     print(double_first(numbers));
  49.     print(double_first(empty));
  50.     print(double_first(strings));
  51. }

This is actually fairly clean now. Compared with the original panic, it
is very similar to replacing the unwrap calls with ? except that the
return types are Result. As a result, they must be destructured at the
top level.

See also:

From::from and ?