• 定义一个错误类型
    • 参见：

    定义一个错误类型

    前面我们一直使用字符串（String）作为错误消息。实际上，字符串作为错误类型是存在一些局限的。下面是友好的错误类型标准。字符串（String）很好地实现了前两点，但无法做到后两点：
    Rust 允许自定义错误类型。一般而言，一个“良好”的错误类型：

    • 使用相同类型来表达不同的错误
    • 给用户提供友好的错误信息
    • 方便和其他类型比较
      • 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())

    可以看到字符串（String）（前面我一们一值在用）可以地满足前两点标准，但后两条无法满足。这使得 String 错误既难以创建，也难以达到要求。仅仅为了优雅地显示，实在不应该使用 String 格式化方式污染大量的逻辑代码（原文：It should not be necessary to pollute logic heavy code with String formatting simply to display nicely.）。

    1. use std::num::ParseIntError;
    2. use std::fmt;
    4. type Result<T> = std::result::Result<T, DoubleError>;
    6. #[derive(Debug)]
    7. // 定义我们的错误类型。不管对我们的错误处理情况有多重要，这些都可能自定义。
    8. // 现在我们能够按照底层工具的错误实现，写下我们的错误，或者两者之间的内容。
    9. // （原文：Define our error types. These may be customized however is useful for our error
    10. // handling cases. Now we will be able to defer to the underlying tools error
    11. // implementation, write our own errors, or something in between.）
    12. enum DoubleError {
    13.     // 我们不需要任何额外的信息来描述这个错误。
    14.     EmptyVec,
    15.     // 我们将推迟对于这些错误的解析错误的实现。（原文：We will defer to the parse
    16.     // error implementation for their error.）提供额外信息将要增加更多针对类型的数据。
    17.     Parse(ParseIntError),
    18. }
    20. // 类型的展示方式的和类型的产生方式是完全独立的。我们无需担心显示样式会搞乱我们
    21. // 工具集所需的复杂逻辑。它们是独立的，就是说它们处理起来是相互独立的。
    22. //
    23. // 我们没有存储关于错误的额外信息。若确实想要，比如，要指出哪个字符串无法解析，
    24. // 那么我们不得不修改我们类型来携带相应的信息。
    25. impl fmt::Display for DoubleError {
    26.     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    27.         match *self {
    28.             DoubleError::EmptyVec =>
    29.                 write!(f, "please use a vector with at least one element"),
    30.             // 这是一个 wrapper，所以按照底层类型来给出我们的 `fmt` 实现。
    31.             // （原上：This is a wrapper so defer to the underlying types' own implementation
    32.             // of `fmt`.）
    33.             DoubleError::Parse(ref e) => e.fmt(f),
    34.         }
    35.     }
    36. }
    38. fn double_first(vec: Vec<&str>) -> Result<i32> {
    39.     vec.first()
    40.        // 将错误改成我们新的类型。
    41.        .ok_or(DoubleError::EmptyVec)
    42.        .and_then(|s| s.parse::<i32>()
    43.              // 在这里也更新成新的错误类型。    
    44.             .map_err(DoubleError::Parse)
    45.             .map(|i| 2 * i))
    46. }
    48. fn print(result: Result<i32>) {
    49.     match result {
    50.         Ok(n)  => println!("The first doubled is {}", n),
    51.         Err(e) => println!("Error: {}", e),
    52.     }
    53. }
    55. fn main() {
    56.     let numbers = vec!["93", "18"];
    57.     let empty = vec![];
    58.     let strings = vec!["tofu", "93", "18"];
    60.     print(double_first(numbers));
    61.     print(double_first(empty));
    62.     print(double_first(strings));
    63. }

    参见：

    Result 和 io::Result