Boxing errors

A way to write simple code while preserving the original errors is to Box
them. The drawback is that the underlying error type is only known at runtime and not
statically determined.

The stdlib helps in boxing our errors by having Box implement conversion from
any type that implements the Error trait into the trait object Box<Error>,
via From.

  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, Clone)]
  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. fn double_first(vec: Vec<&str>) -> Result<i32> {
  29.     vec.first()
  30.        .ok_or_else(|| EmptyVec.into())  // Converts to Box
  31.        .and_then(|s| s.parse::<i32>()
  32.             .map_err(|e| e.into())  // Converts to Box
  33.             .map(|i| 2 * i))
  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. }

See also:

Dynamic dispatch and Error trait