Zenn
👨‍🎓

Rustが目指す「エラーは回復可能であるべき」という哲学

2024/11/24に公開
Rust
embedded
tech

Rustが目指す「エラーは回復可能であるべき」という哲学

プログラムが動作している限り、エラーは必ず発生します。しかし、そのエラーをどう扱うかは言語設計者にとって大きな課題です。Rustは「エラーは回復可能であるべき」という哲学があるように感じます。そのことを示すのが、安全性と実用性を両立したエラーハンドリングの仕組みの提供です。

この記事では、Rustのエラー処理に関する設計思想を具体的なコード例を交えて解説しながら、Result型を中心に、関連する機能や補完的なツールを順を追って紹介します。

1. エラー処理はなぜ重要か？

エラーハンドリングの設計は、ソフトウェア全体の安全性や保守性を大きく左右します。他の言語では、次のようなアプローチが一般的です。

  • 例外（Exception）: エラー時にプログラムの実行を中断してスタックを巻き戻す。
  • エラーステータスコード: 関数がエラーコードを返すことでエラーを通知する。

しかし、これらの方法は以下の問題を抱えています：

  1. 例外は非同期的に発生するため、コードを読むだけではエラーの発生場所や影響範囲がわかりづらい。
  2. エラーステータスコードは無視されることが多く、エラーが適切に処理されないことがある。

Rustはこれらの課題を解決するために、エラー処理を型システムに組み込むアプローチを採用しました。

2. Result型：成功と失敗を明確に表現する

Rustでは、関数の戻り値としてResult型を使用し、操作が成功するか失敗するかを明確に表現します。

2.1 基本構造

Result型は次の2つのバリアントを持っています：

  • Ok(T): 成功時の値。
  • Err(E): 失敗時のエラー情報。

これにより、すべての関数呼び出しでエラー処理を必須とし、失敗ケースを無視できない設計になっています。

使用例：

fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
    if b == 0 {
        Err("Division by zero")
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10, 2) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

2.2 ?演算子：簡潔なエラーハンドリング

Rustでは?演算子を使ってエラーを呼び出し元に伝搬できます。これにより、コードが簡潔になります。

使用例：

fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
    if b == 0 {
        Err("Division by zero")
    } else {
        Ok(a / b)
    }
}

fn calculate() -> Result<(), &'static str> {
    let result = divide(10, 0)?; // エラーが発生した場合即座にリターン
    println!("Result: {}", result);
    Ok(())
}

3. Option型：値が存在するか否かを明確に

Result型と並んで重要なのがOption型です。これは、「値が存在するか否か」を安全に管理するための型で、次の2つのバリアントを持ちます：

  • Some(T): 値が存在する場合。
  • None: 値が存在しない場合。

これは、null参照による実行時エラーを排除するためのRust独自の設計です。

使用例：

fn find_value(key: i32) -> Option<i32> {
    if key == 0 {
        Some(42) // 値が存在する場合
    } else {
        None // 値が存在しない
    }
}

fn main() {
    let value = find_value(0).unwrap_or(0); // デフォルト値を設定
    println!("Value: {}", value);
}

OptionとResultの違い

  • Option型は「値の有無」を表現。
  • Result型は「成功か失敗か」を表現。

Result型にはエラー情報が含まれるため、より詳細な処理が可能です。

4. エラーハンドリングを支えるその他の機能

Rustには、OptionやResult型以外にも、エラーハンドリングを強力にサポートする機能や型が存在します。これらは特定のユースケースや要件に対応し、より柔軟で安全なコードを書くのに役立ちます。

4.1 panic!マクロ：致命的なエラーの報告

panic!マクロは、回復不能なエラーが発生した際にプログラムを即座に終了させます。Result型などで表現できない、致命的なエラーを報告するために使用されます。

使用例：

fn get_element(values: &[i32], index: usize) -> i32 {
    if index < values.len() {
        values[index]
    } else {
        panic!("Index out of bounds")
    }
}

4.2 カスタムエラー型の定義

プロジェクト全体で一貫したエラーハンドリングを実現するには、エラー型を統一することが重要です。列挙型を使用してカスタムエラー型を定義し、詳細なエラー情報を持たせることができます。

使用例：

#[derive(Debug)]
enum MyError {
    DivisionByZero,
    InvalidInput,
    IoError(std::io::Error),
}

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

5. 補完的なエラーハンドリングツール

OptionやResult以外にも、Rustにはエラーハンドリングを補完する様々な型やツールが用意されています。これらを活用することで、特定の状況に応じた効果的なエラーハンドリングが可能になります。

5.1 std::ops::ControlFlow：制御フローのカスタマイズ

ControlFlow型は、ループやイテレーションの中断や継続を制御するために使用されます。ControlFlow::ContinueとControlFlow::Breakの2つのバリアントがあります。

使用例：

use std::ops::ControlFlow;

fn process_items(items: &[i32]) -> ControlFlow<&'static str> {
    for &item in items {
        if item < 0 {
            return ControlFlow::Break("Negative value found");
        }
    }
    ControlFlow::Continue(())
}

5.2 std::io::Result：I/O操作専用のエラー型

std::io::Resultは、Result型のエイリアスで、エラー部分がstd::io::Errorに固定されています。これにより、I/O操作のエラーハンドリングが簡潔になります。

使用例：

use std::fs::File;
use std::io::Result;

fn read_file() -> Result<()> {
    let _file = File::open("example.txt")?; // I/O操作
    Ok(())
}

5.3 Either型：2つの型のいずれかを表現

eitherクレートで提供されるEither型は、2つの異なる型のいずれかを保持します。Either::LeftとEither::Rightの2つのバリアントがあります。

使用例：

use either::Either;

fn divide(a: i32, b: i32) -> Either<&'static str, i32> {
    if b == 0 {
        Either::Left("Division by zero")
    } else {
        Either::Right(a / b)
    }
}

fn main() {
    match divide(10, 0) {
        Either::Left(err) => println!("Error: {}", err),
        Either::Right(result) => println!("Result: {}", result),
    }
}

5.4 Tryトレイト：?演算子の汎用化

Tryトレイトを実装することで、独自の型でも?演算子を使用したエラーハンドリングが可能になります。これにより、OptionやResult以外の型でもエラー処理を統一できます。

6. 組み込み環境（no_std）でのエラー管理

組み込みシステムなど、標準ライブラリを使えない環境（no_std）でも、Rustの型システムはエラー管理をサポートします。no_std環境では、Rustの標準ライブラリ（std）を使用せず、コアライブラリ（core）と一部の補助ライブラリ（allocなど）に制限されます。このため、利用可能な型や構造に制約がありますが、Rustの型システムやno_std向けクレートを活用することで、安全かつ効率的なプログラムが可能です。

6.1 組み込みでも使える型

Option型とResult型

OptionやResult型は標準ライブラリに依存しないため、no_std環境でもそのまま使用可能です。これらの型を利用することで、組み込みシステムでも安全なエラーハンドリングが可能になります。

使用例：
#![no_std]

fn get_pin_state(pin: u8) -> Option<bool> {
    if pin == 0 {
        Some(true) // ピンがHighの場合
    } else {
        None // ピンがLowの場合
    }
}

fn configure_peripheral(value: u8) -> Result<(), &'static str> {
    if value > 100 {
        Err("Value out of range") // エラー
    } else {
        Ok(()) // 正常
    }
}

6.2 no_std向けの補完型

core::convert::Infallible

エラーが「絶対に発生しない」ことを型で保証するために使用されます。Result<T, Infallible>のErrバリアントが使われないことを表現できます。

使用例：
#![no_std]

use core::convert::Infallible;

fn always_succeeds() -> Result<u32, Infallible> {
    Ok(42) // エラーが発生しない関数
}

fn main() {
    match always_succeeds() {
        Ok(value) => {/* 処理 */}
        // Err(_) は存在しない
    }
}

core::ops::ControlFlow

イテレーションやループ制御で中断や継続を表現するために使用されます。標準ライブラリに依存せず、組み込み環境でも制御フローを明確に表現可能です。

使用例：
#![no_std]

use core::ops::ControlFlow;

fn check_pins(pins: &[u8]) -> ControlFlow<u8> {
    for &pin in pins {
        if pin == 0 {
            return ControlFlow::Break(pin); // 異常ピンを発見
        }
    }
    ControlFlow::Continue(())
}

heaplessクレート

heaplessクレートを使用すると、組み込み環境でヒープを使わずにデータ構造を安全に扱えます。OptionやResult型と組み合わせて、データ操作の安全性を高めることができます。

使用例：
#![no_std]

use heapless::Vec; // ヒープレスな固定長ベクタ

fn collect_data() -> Result<Vec<u8, 4>, &'static str> {
    let mut data = Vec::new();
    data.push(1).map_err(|_| "Overflow")?;
    data.push(2).map_err(|_| "Overflow")?;
    data.push(3).map_err(|_| "Overflow")?;
    data.push(4).map_err(|_| "Overflow")?;
    Ok(data) // 正常
}

embedded-errorクレート

embedded-errorクレートは、no_std環境でのエラー管理を効率化するために提供されています。組み込みシステム特有のエラー処理を補助します。

使用例：
#![no_std]

use embedded_error::GenericError;

#[derive(Debug)]
enum MyError {
    PinUnavailable,
    InvalidConfig,
}

impl GenericError for MyError {}

fn configure_pin(pin: u8) -> Result<(), MyError> {
    if pin > 10 {
        Err(MyError::PinUnavailable) // エラー: 無効なピン
    } else {
        Ok(())
    }
}

6.3 非同期処理関連の型（no_std向け）

core::task::Poll

非同期処理や割り込み処理で状態を表現するために使用されます。完了していない処理を安全に扱うことができます。

使用例：
#![no_std]

use core::task::Poll;

fn poll_interrupt() -> Poll<u8> {
    // 割り込み処理の例
    if interrupt_occurred() {
        Poll::Ready(42) // 完了
    } else {
        Poll::Pending // 未完了
    }
}

core::future::Future

非同期プログラミングで使用される型です。async/awaitをサポートしますが、no_std環境では通常のランタイムを使用できないため、embassyやasync-embeddedといったクレートが必要です。

6.4 プリミティブ型の組み合わせ

組み込みシステムでは、フラグやステータスを効率的に管理するためにビット操作が多用されます。

使用例：
#![no_std]

fn check_status(status: u8) -> Option<()> {
    if status & 0b00000001 != 0 {
        Some(()) // フラグが立っている
    } else {
        None // フラグが立っていない
    }
}

7. 非同期処理におけるエラーハンドリング

非同期プログラミングでもエラーハンドリングは重要です。Rustでは、FutureやPollなどの型を用いて非同期処理の結果や状態を管理します。

7.1 std::future::Future：非同期処理の基盤

Futureトレイトは、非同期処理で後に値が生成される可能性を表現します。async/await構文と組み合わせて使用されます。

使用例：

use std::future::Future;

async fn async_compute() -> Result<i32, &'static str> {
    // 非同期処理
    Ok(42)
}

#[tokio::main]
async fn main() {
    match async_compute().await {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

7.2 Poll型：タスクの状態管理

Poll型は、非同期タスクが完了しているかどうかを表現します。Poll::PendingとPoll::Ready(T)の2つのバリアントがあります。

8. unwrap()とexpect()：迅速なエラーハンドリング

OptionやResult型は安全なエラーハンドリングを可能にしますが、場合によってはエラー処理を省略したいこともあります。その際に使用されるのがunwrap()とexpect()メソッドです。

8.1 unwrap()メソッド

unwrap()は、OptionやResult型から中身の値を取り出します。ただし、値が存在しない（NoneやErr）場合はパニックを引き起こします。

使用例（Option）：

fn get_username(id: u32) -> Option<String> {
    if id == 1 {
        Some("Alice".to_string())
    } else {
        None
    }
}

fn main() {
    let username = get_username(1).unwrap();
    println!("Username: {}", username);
}

使用例（Result）：

fn read_file() -> Result<String, std::io::Error> {
    std::fs::read_to_string("config.txt")
}

fn main() {
    let content = read_file().unwrap();
    println!("File content: {}", content);
}

8.2 expect()メソッド

expect()はunwrap()と似ていますが、パニック時にカスタムメッセージを指定できます。エラーの原因を明確にするために推奨されます。

使用例：

fn main() {
    let content = std::fs::read_to_string("config.txt")
        .expect("Failed to read config.txt");
    println!("File content: {}", content);
}

8.3 unwrap()やexpect()の注意点

  • パニック発生: これらのメソッドはエラー時にパニックを引き起こすため、プログラムがクラッシュします。
  • 使用場所の制限: 主にテストコードや、エラーが発生しないことが保証されている場合に使用します。
  • エラーメッセージ: expect()を使うことで、パニック時のメッセージをカスタマイズでき、デバッグが容易になります。

8.4 代替手段

エラーを適切に処理するために、以下の方法を検討します。

  • match式やif let構文でエラーをハンドリングする。
  • **unwrap_orやunwrap_or_else**を使ってデフォルト値を提供する。
  • ?演算子を用いてエラーを呼び出し元に伝搬する。

使用例（unwrap_or）：

fn get_username(id: u32) -> Option<String> {
    if id == 1 {
        Some("Alice".to_string())
    } else {
        None
    }
}

fn main() {
    let username = get_username(2).unwrap_or("Unknown".to_string());
    println!("Username: {}", username);
}

9. まとめ

Rustの「エラーは回復可能であるべき」という哲学は、OptionやResult型を軸に設計されています。これにより、エラーケースを無視できない安全なコードが書けます。また、補完的な型やツールを活用することで、標準環境でも組み込み環境でも一貫したエラーハンドリングが可能です。

さらに、ControlFlowやEither、Tryトレイトなどの補完的な型やトレイトを利用することで、特定のユースケースに合わせたエラーハンドリングや制御フローのカスタマイズが可能になります。非同期処理におけるFutureやPoll、組み込み環境でのエラー管理など、多彩なツールがRustには用意されています。

また、unwrap()やexpect()を適切に使用することで、迅速なエラーハンドリングやデバッグが可能ですが、エラー時にパニックを引き起こすため注意が必要です。

これらの機能を適切に活用することで、より安全で効率的なプログラムを開発できるでしょう。

Discussion