Wrapping errors

An alternative to boxing errors is to wrap them in your own error type.

  1. use std::error;
  2. use std::num::ParseIntError;
  3. use std::fmt;
  5. type Result<T> = std::result::Result<T, DoubleError>;
  7. #[derive(Debug)]
  8. enum DoubleError {
  9.     EmptyVec,
  10.     // We will defer to the parse error implementation for their error.
  11.     // Supplying extra info requires adding more data to the type.
  12.     Parse(ParseIntError),
  13. }
  15. impl fmt::Display for DoubleError {
  16.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  17.         match *self {
  18.             DoubleError::EmptyVec =>
  19.                 write!(f, "please use a vector with at least one element"),
  20.             // This is a wrapper, so defer to the underlying types' implementation of `fmt`.
  21.             DoubleError::Parse(ref e) => e.fmt(f),
  22.         }
  23.     }
  24. }
  26. impl error::Error for DoubleError {
  27.     fn description(&self) -> &str {
  28.         match *self {
  29.             DoubleError::EmptyVec => "empty vectors not allowed",
  30.             // This already impls `Error`, so defer to its own implementation.
  31.             DoubleError::Parse(ref e) => e.description(),
  32.         }
  33.     }
  35.     fn cause(&self) -> Option<&error::Error> {
  36.         match *self {
  37.             DoubleError::EmptyVec => None,
  38.             // The cause is the underlying implementation error type. Is implicitly
  39.             // cast to the trait object `&error::Error`. This works because the
  40.             // underlying type already implements the `Error` trait.
  41.             DoubleError::Parse(ref e) => Some(e),
  42.         }
  43.     }
  44. }
  46. // Implement the conversion from `ParseIntError` to `DoubleError`.
  47. // This will be automatically called by `?` if a `ParseIntError`
  48. // needs to be converted into a `DoubleError`.
  49. impl From<ParseIntError> for DoubleError {
  50.     fn from(err: ParseIntError) -> DoubleError {
  51.         DoubleError::Parse(err)
  52.     }
  53. }
  55. fn double_first(vec: Vec<&str>) -> Result<i32> {
  56.     let first = vec.first().ok_or(DoubleError::EmptyVec)?;
  57.     let parsed = first.parse::<i32>()?;
  59.     Ok(2 * parsed)
  60. }
  62. fn print(result: Result<i32>) {
  63.     match result {
  64.         Ok(n)  => println!("The first doubled is {}", n),
  65.         Err(e) => println!("Error: {}", e),
  66.     }
  67. }
  69. fn main() {
  70.     let numbers = vec!["42", "93", "18"];
  71.     let empty = vec![];
  72.     let strings = vec!["tofu", "93", "18"];
  74.     print(double_first(numbers));
  75.     print(double_first(empty));
  76.     print(double_first(strings));
  77. }

This adds a bit more boilerplate for handling errors and might not be needed in
all applications. There are some libraries that can take care of the boilerplate
for you.

See also:

From::from and Enums