包裹错误

把错误装箱这种做法也可以改成把它包裹到你自己的错误类型中。

  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.     // 在这个错误类型中，我们采用 `parse` 的错误类型中 `Err` 部分的实现。
  11.     // 若想提供更多信息，则该类型中还需要加入更多数据。
  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.             // 这是一个封装（wrapper），它采用内部各类型对 `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.             // 这已经实现了 `Error`，所以采用它自己的实现。
  31.             DoubleError::Parse(ref e) => e.description(),
  32.         }
  33.     }
  35.     fn cause(&self) -> Option<&error::Error> {
  36.         match *self {
  37.             DoubleError::EmptyVec => None,
  38.             // 原因采取内部对错误类型的实现。它隐式地转换成了 trait 对象 `&error:Error`。
  39.             // 这可以工作，因为内部的类型已经实现了 `Error` trait。
  40.             DoubleError::Parse(ref e) => Some(e),
  41.         }
  42.     }
  43. }
  45. // 实现从 `ParseIntError` 到 `DoubleError` 的转换。
  46. // 在使用 `?` 时，或者一个 `ParseIntError` 需要转换成 `DoubleError` 时，它会被自动调用。
  47. impl From<ParseIntError> for DoubleError {
  48.     fn from(err: ParseIntError) -> DoubleError {
  49.         DoubleError::Parse(err)
  50.     }
  51. }
  53. fn double_first(vec: Vec<&str>) -> Result<i32> {
  54.     let first = vec.first().ok_or(DoubleError::EmptyVec)?;
  55.     let parsed = first.parse::<i32>()?;
  57.     Ok(2 * parsed)
  58. }
  60. fn print(result: Result<i32>) {
  61.     match result {
  62.         Ok(n)  => println!("The first doubled is {}", n),
  63.         Err(e) => println!("Error: {}", e),
  64.     }
  65. }
  67. fn main() {
  68.     let numbers = vec!["42", "93", "18"];
  69.     let empty = vec![];
  70.     let strings = vec!["tofu", "93", "18"];
  72.     print(double_first(numbers));
  73.     print(double_first(empty));
  74.     print(double_first(strings));
  75. }

这种做法会在错误处理中增加一些模板化的代码，而且也不是所有的应用都需要这样做。一些 库可以帮你处理模板化代码的问题。

See also:

From::from and 枚举类型