Result<T, E> — 回復可能なエラーのサンプルコード — Rust

1Ok と Err を返す最小の関数

成功なら Ok(値)、失敗なら Err(メッセージ) を返す、いちばん素朴な Result の形です。Option との違いは「なぜ失敗したか」をエラー値として持てることです。呼び出し側は match で両方のケースを必ず処理します。

Rust

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("0 では割れません")) // 失敗の理由を値で返す
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10, 2) {
        Ok(n) => println!("結果: {}", n),
        Err(e) => println!("エラー: {}", e),
    }
    match divide(10, 0) {
        Ok(n) => println!("結果: {}", n),
        Err(e) => println!("エラー: {}", e),
    }
}

2標準ライブラリの parse は Result を返す

文字列を数値に変換する parse は、失敗しうるので Result を返します。自作関数だけでなく、標準ライブラリの失敗しうる操作はほぼすべてこの形だと体感する例です。Err に入っているエラー値も {} でそのまま表示できます。

Rust

fn main() {
    let inputs = ["42", "abc", "-7"];
    for input in &inputs {
        match input.parse::<i32>() {
            Ok(n) => println!("'{}' は数値 {} に変換できた", input, n),
            Err(e) => println!("'{}' は変換失敗: {}", input, e),
        }
    }
}

3複数の検証ルールと早期リターン

検証ルールが複数あるときは、違反を見つけた時点で return Err(...) して抜けるのが読みやすい形です。どのルールに違反したかがエラーメッセージとして呼び出し元に届きます。フォーム入力やAPIリクエストの検証処理がまさにこの形になります。

Rust

fn validate_age(age: i32) -> Result<i32, String> {
    if age < 0 {
        return Err(String::from("年齢が負の数です"));
    }
    if age > 150 {
        return Err(String::from("年齢が大きすぎます"));
    }
    Ok(age) // すべての検証を通過
}

fn main() {
    for age in &[25, -5, 200] {
        match validate_age(*age) {
            Ok(n) => println!("{} 歳: OK", n),
            Err(e) => println!("{} 歳: {}", age, e),
        }
    }
}

4enum で独自のエラー型を作る

エラーの種類が複数あるなら、文字列ではなく enum でエラー型を定義すると、呼び出し側が match でエラーの種類ごとに対応を分けられます。「見つからない」と「権限がない」で挙動を変えるような分岐が型安全に書けます。実務のライブラリやAPIクライアントのエラー設計の基本形です。

Rust

enum FetchError {
    NotFound,
    Forbidden,
}

fn fetch_user(id: u32) -> Result<String, FetchError> {
    if id == 1 {
        Ok(String::from("Alice"))
    } else if id == 2 {
        Err(FetchError::Forbidden)
    } else {
        Err(FetchError::NotFound)
    }
}

fn main() {
    for id in 1..=3 {
        match fetch_user(id) {
            Ok(name) => println!("id {}: {} を取得", id, name),
            Err(FetchError::Forbidden) => println!("id {}: 権限がありません", id),
            Err(FetchError::NotFound) => println!("id {}: 見つかりません", id),
        }
    }
}

5失敗をスキップしながらバッチ処理する

複数件のデータを処理するとき、Result を match でさばけば「失敗した行はスキップして続行し、最後に件数を報告する」が自然に書けます。例外機構と違い、1件の失敗で全体が止まらない設計が標準になります。CSV の取り込みやログの集計など、実務のバッチ処理の典型です。

Rust

fn main() {
    let inputs = ["10", "abc", "30", "", "50"];
    let mut total = 0;
    let mut ok_count = 0;
    let mut err_count = 0;
    for input in &inputs {
        match input.parse::<i32>() {
            Ok(n) => {
                total += n;
                ok_count += 1;
            }
            Err(_) => {
                println!("'{}' は数値として読めずスキップ", input);
                err_count += 1;
            }
        }
    }
    println!("成功 {} 件 / 失敗 {} 件 / 合計 {}", ok_count, err_count, total);
}

サンプルコードで身につける: Result<T, E> — 回復可能なエラー

1Ok と Err を返す最小の関数

2標準ライブラリの parse は Result を返す

3複数の検証ルールと早期リターン

4enum で独自のエラー型を作る

5失敗をスキップしながらバッチ処理する