カスタムエラー型 / thiserror

use std::fmt;
use std::error::Error;

// カスタムエラー型を定義します。
#[derive(Debug)]
enum AppError {
    NotFound(String),
    ParseError(String),
    IoError(std::io::Error),
}

// Display トレイトを実装してエラーメッセージを定義します。
impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AppError::NotFound(s) => write!(f, "見つかりません: {}", s),
            AppError::ParseError(s) => write!(f, "パースエラー: {}", s),
            AppError::IoError(e) => write!(f, "I/Oエラー: {}", e),
        }
    }
}

// Error トレイトを実装します（空の実装でOKです）。
impl Error for AppError {}

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

#[derive(Debug)]
enum CalcError {
    DivisionByZero,
    Overflow,
    ParseError(ParseIntError),
}

impl fmt::Display for CalcError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CalcError::DivisionByZero => write!(f, "ゼロ除算エラーです"),
            CalcError::Overflow => write!(f, "オーバーフローが発生しました"),
            CalcError::ParseError(e) => write!(f, "数値パースエラー: {}", e),
        }
    }
}

impl Error for CalcError {}

// ParseIntError から CalcError に自動変換します（? 演算子を使えます）。
impl From<ParseIntError> for CalcError {
    fn from(e: ParseIntError) -> Self {
        CalcError::ParseError(e)
    }
}

// 自作Result型エイリアスです。
type CalcResult<T> = Result<T, CalcError>;

fn divide(a: i32, b: i32) -> CalcResult<i32> {
    if b == 0 {
        Err(CalcError::DivisionByZero)
    } else {
        Ok(a / b)
    }
}

// ? 演算子でParseIntErrorをCalcErrorに自動変換します。
fn parse_and_divide(a: &str, b: &str) -> CalcResult<i32> {
    let a: i32 = a.parse()?;  // ParseIntError が CalcError::ParseError に変換されます。
    let b: i32 = b.parse()?;
    divide(a, b)
}

fn main() {
    // 正常な計算です。
    match divide(10, 2) {
        Ok(result) => println!("10 / 2 = {}", result),
        Err(e) => println!("エラー: {}", e),
    }

    // ゼロ除算です。
    match divide(10, 0) {
        Ok(result) => println!("結果: {}", result),
        Err(e) => println!("エラー: {}", e),
    }

    // 文字列のパースを含む計算です。
    let cases = vec![
        ("20", "4"),
        ("abc", "4"),
        ("20", "0"),
    ];

    for (a, b) in cases {
        match parse_and_divide(a, b) {
            Ok(result) => println!("{} / {} = {}", a, b, result),
            Err(e) => println!("{} / {} エラー: {} ({:?})", a, b, e, e),
        }
    }

    // Box<dyn Error> を使う簡易版です（複数のエラー型を返せます）。
    fn flexible_error(fail: bool) -> Result<i32, Box<dyn Error>> {
        if fail {
            Err("シンプルなエラー".into())
        } else {
            Ok(42)
        }
    }
    println!("{:?}", flexible_error(false));
    println!("{:?}", flexible_error(true));
}

カスタムエラー型に『From<OtherError>』を実装しておくと、『?』演算子が自動でエラーを変換してくれます。これにより複数の種類のエラーが発生する関数でも、シンプルなコードで書けます。

本格的なアプリケーションでは『thiserror』クレートが便利です。『#[derive(Error)]』マクロで『Display』と『Error』の実装を自動化できます。

Resultの基本操作は『Result::unwrap() / expect() / ? 演算子』を参照してください。