エラーをラップする - Rust By Example
Description: Rust by Example (RBE) is a collection of runnable examples that illustrate various Rust concepts and standard libraries.

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# エラーをラップする

Boxする方法の代替として、エラーを自前のエラー型としてラップする方法もあります。

    use std::error;
    use std::error::Error;
    use std::num::ParseIntError;
    use std::fmt;

    type Result<T> = std::result::Result<T, DoubleError>;

    #[derive(Debug)]
    enum DoubleError {
        EmptyVec,
        // パースエラーの実装まで処理を委譲します。
        // 追加の情報を提供するには、型により多くのデータを追加する必要があります。
        Parse(ParseIntError),
    }

    impl fmt::Display for DoubleError {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            match *self {
                DoubleError::EmptyVec =>
                    write!(f, "please use a vector with at least one element"),
                // ラップされたエラーは追加情報を含み、
                // source メソッドから取り出すことができます。
                DoubleError::Parse(..) =>
                    write!(f, "the provided string could not be parsed as int"),
            }
        }
    }

    impl error::Error for DoubleError {
        fn source(&self) -> Option<&(dyn error::Error + 'static)> {
            match *self {
                DoubleError::EmptyVec => None,
                // 元の実装のエラー型が原因。
                // `&error::Error`トレイトオブジェクトに暗にキャストされます。
                // 元となる型が`Error`トレイトをすでに実装しているため問題ありません。
                DoubleError::Parse(ref e) => Some(e),
            }
        }
    }

    // `ParseIntError`から`DoubleError`への変換の実装。
    // `ParseIntError`が`DoubleError`に変換される必要がある時、
    // 自動的に`?`から呼び出されます。
    impl From<ParseIntError> for DoubleError {
        fn from(err: ParseIntError) -> DoubleError {
            DoubleError::Parse(err)
        }
    }

    fn double_first(vec: Vec<&str>) -> Result<i32> {
        let first = vec.first().ok_or(DoubleError::EmptyVec)?;
        // Here we implicitly use the `ParseIntError` implementation of `From` (which
        // we defined above) in order to create a `DoubleError`.
        let parsed = first.parse::<i32>()?;

        Ok(2 * parsed)
    }

    fn print(result: Result<i32>) {
        match result {
            Ok(n)  => println!("The first doubled is {}", n),
            Err(e) => {
                println!("Error: {}", e);
                if let Some(source) = e.source() {
                    println!("  Caused by: {}", source);
                }
            },
        }
    }

    fn main() {
        let numbers = vec!["42", "93", "18"];
        let empty = vec![];
        let strings = vec!["tofu", "93", "18"];

        print(double_first(numbers));
        print(double_first(empty));
        print(double_first(strings));
    }

これはエラーの処理のボイラープレートを増やしてしまい、全てのアプリケーションで必要になる訳では無いでしょう。これらのボイラープレートの処理を代わりにやってくれるようなライブラリもあります。

### 参照

`From::from`, 列挙型

`Crates for handling errors`