Defining an error type

Sometimes it simplifies the code to mask all of the different errors with a
single type of error. We’ll show this with a custom error.

Rust allows us to define our own error types. In general, a “good” error type:

  • Represents different errors with the same type
  • Presents nice error messages to the user
  • Is easy to compare with other types
    • Good: Err(EmptyVec)
    • Bad: Err("Please use a vector with at least one element".to_owned())
  • Can hold information about the error
    • Good: Err(BadChar(c, position))
    • Bad: Err("+ cannot be used here".to_owned())
  • Composes well with other errors
  1. use std::error;
  2. use std::fmt;
  3. use std::num::ParseIntError;
  5. type Result<T> = std::result::Result<T, DoubleError>;
  7. #[derive(Debug, Clone)]
  8. // Define our error types. These may be customized for our error handling cases.
  9. // Now we will be able to write our own errors, defer to an underlying error
  10. // implementation, or do something in between.
  11. struct DoubleError;
  13. // Generation of an error is completely separate from how it is displayed.
  14. // There's no need to be concerned about cluttering complex logic with the display style.
  15. //
  16. // Note that we don't store any extra info about the errors. This means we can't state
  17. // which string failed to parse without modifying our types to carry that information.
  18. impl fmt::Display for DoubleError {
  19.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  20.         write!(f, "invalid first item to double")
  21.     }
  22. }
  24. // This is important for other errors to wrap this one.
  25. impl error::Error for DoubleError {
  26.     fn description(&self) -> &str {
  27.         "invalid first item to double"
  28.     }
  30.     fn cause(&self) -> Option<&error::Error> {
  31.         // Generic error, underlying cause isn't tracked.
  32.         None
  33.     }
  34. }
  36. fn double_first(vec: Vec<&str>) -> Result<i32> {
  37.     vec.first()
  38.        // Change the error to our new type.
  39.        .ok_or(DoubleError)
  40.        .and_then(|s| s.parse::<i32>()
  41.             // Update to the new error type here also.
  42.             .map_err(|_| DoubleError)
  43.             .map(|i| 2 * i))
  44. }
  46. fn print(result: Result<i32>) {
  47.     match result {
  48.         Ok(n)  => println!("The first doubled is {}", n),
  49.         Err(e) => println!("Error: {}", e),
  50.     }
  51. }
  53. fn main() {
  54.     let numbers = vec!["42", "93", "18"];
  55.     let empty = vec![];
  56.     let strings = vec!["tofu", "93", "18"];
  58.     print(double_first(numbers));
  59.     print(double_first(empty));
  60.     print(double_first(strings));
  61. }