- 1. はじめに：Rustがエラー処理を最重要視する理由
- 2. Option<T>：値の有無を明示的に表現する
- 3. Result<T, E>：回復可能なエラーを扱う
- 4. ?演算子：エレガントなエラー伝播
- 5. OptionとResultを組み合わせた実用的なパターン
- 6. 実践的なエラーハンドリングとメソッドチェイン
- 7. 結論：Rustのエラー処理は読みやすいコードの第一歩
1. はじめに：Rustがエラー処理を最重要視する理由
多くのプログラミング言語では、エラー処理は本質的なロジックの後に付け足されるような存在と見なされがちです。しかし、Rustでは違います。Rustは「安全性」と「予測可能性」を最重要視して設計された言語であり、エラー処理はその哲学の中心に据えられています。
Rustでは、nullポインタや例外（exception）を使用せず、代わりに Option 型と Result 型という二つの強力な列挙型（enum）を導入しています。これにより、「値が存在しない可能性」や「処理が失敗する可能性」を明示的に表現でき、コンパイル時に漏れなく処理を網羅することが求められます。
初めてRustを学ぶ人にとって、Option や Result、そして ? 演算子は難解に感じられるかもしれません。どの場面で unwrap を使うべきか、match で分岐すべきか、? はどの関数で使えるのか――そのような疑問に対し、本記事では丁寧かつ体系的に解説していきます。
このガイドでは、Rustにおけるエラー処理の基礎から実践まで、豊富なコード例と共に詳しく解説します。読みやすく、安全で、拡張性のあるRustコードを書くための第一歩として、ぜひ最後までお読みください。
2. Option<T>：値の有無を明示的に表現する
Rustにおける Option<T> 型は、「値が存在するかもしれないし、存在しないかもしれない」という状態を明示的に表現するための型です。これは他言語でよく見られる null 参照や未定義の挙動を排除し、プログラムの安全性を高める設計です。
Option は次のように定義されています：
enum Option<T> {
Some(T),
None,
}
これはつまり、Option<T> 型の変数は Some(value)（値あり）か None（値なし）のいずれかであるということです。このモデルによって、すべてのパターンを明示的に処理する必要があり、nullによるクラッシュを未然に防ぐことができます。
2.1 match文による安全な分岐
Option 型を扱う際、最も基本的かつ安全な方法が match 式を使ったパターンマッチングです。すべてのケースを明確に処理することを強制されるため、安全かつ読みやすいコードが書けます。
fn divide(numerator: f64, denominator: f64) -> Option<f64> {
if denominator == 0.0 {
None
} else {
Some(numerator / denominator)
}
}
fn main() {
let result = divide(10.0, 2.0);
match result {
Some(value) => println!("結果: {}", value),
None => println!("0で割ることはできません"),
}
}
2.2 unwrap_orでデフォルト値を指定する
もし None の場合に備えてデフォルト値を設定したいのであれば、unwrap_or を使うと便利です。
let value = divide(10.0, 0.0).unwrap_or(0.0);
println!("安全な結果: {}", value);
unwrap_or は Some の場合は中身の値を返し、None の場合は指定されたデフォルト値を返します。
2.3 mapとand_thenによる変換とチェイン
関数型スタイルで Option を扱うには、map と and_then を使うのが便利です。map は Some の値を変換し、None はそのまま保持します。and_then は変換後に再び Option を返す処理に適しています。
let result = divide(10.0, 2.0)
.map(|x| x + 1.0)
.and_then(|x| if x > 5.0 { Some(x * 2.0) } else { None });
match result {
Some(val) => println!("変換後の結果: {}", val),
None => println!("有効な結果が得られませんでした"),
}
このように Option は、安全性と柔軟性を両立しつつ、読みやすいコードを実現する強力なツールです。次のセクションでは、エラー情報を含む Result<T, E> の活用方法を見ていきます。
3. Result<T, E>：回復可能なエラーを扱う
Option が「値があるかどうか」を表すのに対し、Result は「操作が成功したか失敗したか」、そして「失敗した場合にはその理由」を明示的に表現するための型です。これは、ファイルの読み込みや文字列のパースなど、エラーが起こり得る処理において非常に有用です。
Result は以下のように定義されています：
enum Result<T, E> {
Ok(T),
Err(E),
}
Ok は成功時の値を、Err は失敗時のエラー情報を保持します。これにより、より豊富な文脈をもってエラーを処理することができます。
3.1 matchによるResultの分岐処理
Result も Option 同様に match 式で扱うのが基本です。すべてのケースを網羅的に処理でき、安全で意図が明確なコードになります。
fn parse_number(text: &str) -> Result<i32, std::num::ParseIntError> {
text.parse()
}
fn main() {
match parse_number("42") {
Ok(n) => println!("パース成功: {}", n),
Err(e) => println!("パース失敗: {}", e),
}
}
3.2 unwrap_or_elseとexpectによる簡潔な処理
エラー発生時にフォールバック処理をしたり、明示的にパニックを起こしたい場合には unwrap_or_else や expect を使うことができます。
let number = parse_number("abc").unwrap_or_else(|err| {
println!("エラー発生: {}", err);
0
});
println!("結果: {}", number);
let number = parse_number("42").expect("数値のパースに失敗しました");
unwrap_or_else はエラー時に独自の処理を挿入できます。expect はパニック時のメッセージをカスタムでき、開発中のバグ検出に役立ちます。
3.3 map、and_then、or_elseによるチェイン処理
Result も Option と同様に、関数型のチェイン処理に対応しています。これにより、読みやすく再利用可能な処理フローを構築できます。
fn double_number(text: &str) -> Result<i32, std::num::ParseIntError> {
text.parse::().map(|n| n * 2)
}
let result = double_number("21")
.map(|n| n + 1)
.and_then(|n| if n % 2 == 0 { Ok(n / 2) } else { Err("2で割り切れません".into()) });
match result {
Ok(val) => println!("最終結果: {}", val),
Err(e) => println!("エラー発生: {}", e),
}
このように Result は、エラーとその文脈を持った安全な処理を実現します。次の章では、これらのエラーをさらに簡潔に伝播するための ? 演算子について詳しく解説します。
4. ?演算子：エレガントなエラー伝播
Rustの ? 演算子は、Result または Option 型に対して使用できるシンタックスシュガーであり、エラー処理を簡潔かつ読みやすく記述することができます。これにより、ネストされた match 文や冗長な分岐処理を避け、直線的な制御フローを実現します。
4.1 ?演算子の基本動作
? は、値が Ok（または Some）であれば中身を取り出し処理を継続し、Err（または None）であればその時点で現在の関数から即時リターンします。
fn read_number_from_str(s: &str) -> Result<i32, std::num::ParseIntError> {
let n = s.parse()?; // エラーがあればここで関数から返る
Ok(n)
}
この記法により、 match を使わずにエラーを上位へ「伝播」させることができ、非常に読みやすいコードが書けます。
4.2 使用条件：戻り値の型に注意
? を使うためには、その関数自身の戻り値の型が Result または Option でなければなりません。そうでなければ、コンパイルエラーとなります。
fn invalid_use() {
let num = "123".parse()?; // エラー：戻り値が Result ではない
}
上記を正しく書くには、関数の戻り値を Result にする必要があります：
fn valid_use() -> Result<i32, std::num::ParseIntError> {
let num = "123".parse()?;
Ok(num)
}
4.3 複数のエラー型を統一して伝播する
現実のアプリケーションでは、異なるエラー型が混在することがよくあります。このような場合、すべてのエラーを1つの型に統一する必要があります。その方法の一つが Box<dyn std::error::Error> を使うことです。
use std::fs::File;
use std::io::{self, Read};
fn read_file_content(path: &str) -> Result<String, Box<dyn std::error::Error>> {
let mut file = File::open(path)?;
let mut contents = String::new();
file.read_to_string(&mut contents)?;
Ok(contents)
}
このようにすることで、ファイル操作やパース処理など、さまざまな種類のエラーを一元的に扱うことができ、? 演算子を使ったエラー伝播がスムーズに行えるようになります。
次の章では、Option と Result を組み合わせて使う実践的なパターンや、それらを相互に変換する方法について解説します。
5. OptionとResultを組み合わせた実用的なパターン
実際のプログラムでは、値が「存在しない」かつ「何らかのエラーが発生する」可能性の両方を扱う必要がある場面が頻繁に登場します。Rustでは Option<T> と Result<T, E> をうまく組み合わせて、そうしたケースを安全かつ柔軟に処理できます。
5.1 OptionをResultに変換する：ok_or / ok_or_else
Option 型の値を、エラーメッセージ付きの Result に変換するには、ok_or または ok_or_else を使用します。値が None だった場合に、指定したエラーを Err として返すことができます。
fn find_user(id: u32) -> Option<&'static str> {
if id == 1 {
Some("alice")
} else {
None
}
}
fn find_user_result(id: u32) -> Result<&'static str, String> {
find_user(id).ok_or("ユーザーが見つかりません".to_string())
}
ok_or_else はエラーメッセージの生成処理を遅延評価するため、パフォーマンスや複雑な処理に適しています。
let result = find_user(2).ok_or_else(|| format!("ID {} のユーザーは存在しません", 2));
5.2 ResultをOptionに変換する：ok / err
逆に、Result を Option に変換することで、エラーの詳細を気にせず「成功か否か」だけを判定したいときに便利です。これは ok() や err() メソッドで実現できます。
let value: Option<i32> = "123".parse().ok();
let error: Option<std::num::ParseIntError> = "abc".parse::<i32>().err();
この変換は filter_map などのイテレータ処理や、単純な条件分岐の中で役立ちます。
5.3 ネスト型の整理：transposeの活用
実装が進むと、Option<Result<T, E>> や Result<Option<T>, E> のようなネストされた型が現れることがあります。こうした場合、transpose メソッドを使えば、構造を反転してより自然な型に変換できます。
let nested: Option<Result<i32, &str>> = Some(Ok(5));
let flattened: Result<Option<i32>, &str> = nested.transpose();
transpose を使うことで、関数の返り値の整合性を保ちつつ、処理の読みやすさも大幅に向上させることができます。
次章では、ここまで紹介してきた Option、Result、そして ? を駆使して、実際にどのようにメソッドチェインや関数設計を行うか、実践的なコード例で紹介します。
6. 実践的なエラーハンドリングとメソッドチェイン
ここまでに紹介してきた Option、Result、? 演算子、および各種チェインメソッド（map、and_then など）は、個々に使っても強力ですが、組み合わせることでより表現力のあるコードが書けます。このセクションでは、それらを統合して現実的なコード例を示し、エラー処理のスタイルと流れを具体的に解説します。
6.1 実例：ファイルから数値を読み込んで計算する
以下は、ファイルの内容を読み込み、文字列から数値をパースし、計算結果を返すという典型的なフローです。複数のエラーが起こり得るため、Result と ? を併用して、明快で堅牢なコードを実現します。
use std::fs::File;
use std::io::{self, Read};
use std::num::ParseIntError;
fn read_file(path: &str) -> Result<String, io::Error> {
let mut file = File::open(path)?;
let mut contents = String::new();
file.read_to_string(&mut contents)?;
Ok(contents)
}
fn parse_and_calculate(data: &str) -> Result<i32, ParseIntError> {
let number: i32 = data.trim().parse()?;
Ok(number * 2)
}
fn process(path: &str) -> Result<i32, Box<dyn std::error::Error>> {
let content = read_file(path)?;
let result = parse_and_calculate(&content)?;
Ok(result)
}
fn main() {
match process("data.txt") {
Ok(val) => println!("計算結果: {}", val),
Err(e) => eprintln!("エラーが発生しました: {}", e),
}
}
このコードでは、エラー処理が ? 演算子により直感的かつ簡潔に記述されており、ファイル入出力と文字列パースという2種類の異なるエラーも Box<dyn Error> を使って一元管理しています。
6.2 map、and_then、unwrap_or_else による関数型スタイル
関数型スタイルの記述によって、より短く、可読性の高いエラー処理も可能です。以下は、Option から始まる値の処理フローの一例です：
fn transform_input(input: Option<&str>) -> Result<i32, String> {
input
.ok_or("入力が指定されていません".to_string())?
.trim()
.parse::<i32>()
.map_err(|_| "数値の形式が正しくありません".to_string())
}
この例では、Option を ok_or で Result に変換し、トリムとパース処理をチェインしながら、すべてのエラーをユーザー向けの文字列でカスタムしています。
6.3 テクニック早見表：どのパターンをいつ使うか
| テクニック | 用途 |
|---|---|
| match | すべてのケースを明示的に分岐させたいとき |
| unwrap_or / unwrap_or_else | デフォルト値やフォールバック処理をしたいとき |
| map / and_then | 処理をチェインしつつ、変換やフィルタを行いたいとき |
| ? | 明確で簡潔なエラー伝播を行いたいとき |
次章では、これまでのポイントを振り返りながら、Rustらしいエラー処理とは何か、その本質に迫ります。
7. 結論：Rustのエラー処理は読みやすいコードの第一歩
Rustのエラー処理は、単なる障害回避の手段ではなく、プログラムの設計そのものに密接に関わる重要な概念です。Option と Result による明示的な状態管理、? 演算子による簡潔な伝播、そして関数型スタイルのチェイン処理は、エラー処理を「安全」で「読みやすく」「再利用性の高い」ものにします。
この投稿で学んだことを振り返りましょう：
Optionによって「値の有無」を安全に表現し、null参照を排除するResultによって「失敗の理由」を明示的に取り扱い、エラーの文脈を保つ?演算子で直線的かつ読みやすいエラーフローを実現するmapやand_thenによって処理のチェインを安全に構成するok_orやtransposeによる型変換で柔軟なインターフェース設計を可能にする
Rustでは、すべてのエラーを明示的に扱うことが求められます。これは一見すると煩雑に感じられるかもしれませんが、慣れればその恩恵の大きさに気付くはずです。コンパイラがエラー処理の抜け漏れを防いでくれるため、開発者はより安心してコードを書くことができます。
本質的に、Rustのエラー処理は「未来の自分や他の開発者にとって読みやすく、予測可能なコードを書くための道具」です。単に「壊れない」コードではなく、「意図が明確で保守しやすい」コードを目指すとき、Rustのエラー処理はその強力な武器となるでしょう。
ぜひこの知識を実践に活かし、安全で美しいRustコードを書いていきましょう。