エラーハンドリングで破綻しない!RustのResult型を正しく洗練させるためのベストプラクティス

RustのResult型を用いた洗練されたエラーハンドリングを表現するヒーロー画像。型設計とpanic・Resultの対比を示す プログラミング言語

プロダクションで火を噴くバグの多くは、正常系ではなく異常系で生まれます。
境界条件の漏れ、ネットワークの一時的な失敗、想定外の入力フォーマット――こうした「例外」は、型を設計する段階で正しく扱えていれば、実行時ではなくコンパイル時に検知できたはずです。

RustのResult<T, E>は、この異常系を第一級の値としてコードの上に持ち上げるための仕組みです。
成功と失敗が対称に表現され、失敗の理由までが型に包まれることで、呼び出し側は「次に何をすべきか」をコンパイラと一緒に考えさせられます。

とはいえ、この表現力を実務で生かし切るには、知識だけでは足りない場面が多くあります。

  • ?演算子の背後で動くFrom変換を、どの粒度で定義すべきか
  • クレート・モジュール・関数それぞれで、エラー型をどう設計するか
  • ライブラリ作者とアプリケーション作者で、thiserrorとanyhowをいつ切り替えるか
  • unwrap・expect・panic!を、どこまで「設計上の境界」として許容するか

本記事では、こうした判断軸を失敗を値として扱うというRustの設計哲学から整理し、再現可能なベストプラクティスとして提示します。
読了後には、Resultを扱う指の動きが一段速くなっているはずです。

  1. なぜRustのエラーハンドリングは他言語と根本的に違うのか
    1. 例外とResult ― 型が表現する「失敗」の意味
    2. panicとResultの境界線を引く
    3. 失敗を「値」として扱うRustの設計哲学
  2. RustのResult型入門 ― OkとErrの基本構造
    1. Resultの定義と2つのバリアント
    2. matchとif letで結果を分解する
    3. unwrapとexpectの落とし穴
  3. ?演算子の仕組みとエラー伝播のベストプラクティス
    1. ?演算子が内部で行う3つの処理
    2. From変換でエラー型を自動変換する
    3. ?演算子を使うとき・使わないときの判断軸
  4. カスタムエラー型の設計 ― クレート・モジュールの粒度で分ける
    1. 単一エラー型 vs 複数エラー型の使い分け
    2. thiserrorでボイラープレートを削減する
    3. From実装でエラー型を階層化する
    4. エラー型に含めるべき情報 ― コンテキスト・原因・位置
  5. thiserrorとanyhowの使い分け ― ライブラリとアプリの境界
    1. ライブラリはthiserror、アプリはanyhowという基本原則
    2. anyhow::Errorとanyhow::Resultの実装パターン
    3. 境界でanyhowからthiserrorへ変換する
  6. panic・unwrap・expect ― 設計上「許される」境界線の引き方
    1. プロトタイプでは許されるpanic
    2. 到達不能コードをpanic!で表現する
    3. ライブラリAPIでpanicを呼び出してはいけない理由
  7. 実務で陥るアンチパターンと回避策
    1. Boxに逃げるな
    2. エラーを握り潰すsilent failure
    3. 文字列でエラーを返すな ― 型情報を持たせる
  8. まとめ ― Result型を「負担」から「表現」に変えるために
    1. 失敗を値として扱う ― 一貫した哲学
    2. 判断軸の早見表
    3. 負担ではなく表現へ

なぜRustのエラーハンドリングは他言語と根本的に違うのか

RustのResult型と他言語の例外処理の違いを、プログラミング設計の観点から表現したアイキャッチ

この問いに答えるためには、まず「失敗」がコードの上でどう表現されるか、という言語設計の差分を見直す必要があります。
多くのプログラミング言語では、例外(exception)という制御構造を用いて失敗を伝えます。
try/catchを飛び越え、関数のシグネチャには現れない経路で、想定外の失敗がスタックを遡っていきます。
便利に見えますが、その便利さは「失敗の取り扱いから設計者の目を逃がす」ことと引き換えです。

例外とResult ― 型が表現する「失敗」の意味

他言語の例外モデルでは、readFileが「成功して文字列を返す」ことは型シグネチャから読めますが、「失敗する可能性」は読めません。
失敗は文書化されるか、慣習的に知らされているに過ぎず、コンパイラは何も保証しません。

RustのResult<T, E>は、この構造をひっくり返します。
std::fs::read_to_stringの戻り値はResult<String, io::Error>であり、呼び出しに成功も失敗も等しく型の中に格納されていることがシグネチャを読むだけで確定します。
コンパイラは、未処理のErrがあればビルドを通しません。
つまり「失敗の取り扱い」は、設計者個人の注意力ではなく、言語と型システムが共同で強制する責務になるわけです。

panicとResultの境界線を引く

Rustにはもうひとつ、panic!という失敗表現があります。
これは回復不能な状態を意味する仕組みで、スタックを巻き戻しつつプロセスを異常終了させます。
「Resultがあるのになぜpanicがあるのか」と感じる方も多いかもしれませんが、両者の責務は明確に分かれています。

  • Resultは予期される失敗 ― I/O、ユーザ入力、パース、外部API
  • panic!は契約違反 ― 到達不能コード、配列の境界外、不変条件の破壊

プログラムが正しく書かれている限り起きない失敗は、起きた瞬間に「ロジック側のバグ」です。
Resultに押し込めても対処のしようがない失敗を呼び出し側に渡すより、panic!で即座に停止する方が、デバッグも復旧も容易になります。

失敗を「値」として扱うRustの設計哲学

ここまでの話を貫く一本の線を引くなら、「失敗を値として扱う」というRustの設計哲学に行き着きます。
例外モデルでは失敗は制御フローの側道に過ぎず、変数に代入できず、合成できず、型として扱えません。

一方、ResultをはじめとするRustのエラー型は、変数に束縛でき、関数の引数として渡せ、戻り値として返せ、?演算子で合成できます。
失敗が第一級の市民として他の値と並んでいるからこそ、エラーハンドリングは「特別な注意」ではなく「通常のプログラミング」の一部として書けるのです。

次の章からは、このResultを実際にどう扱うか、基本構文から順に洗練させていきます。

RustのResult型入門 ― OkとErrの基本構造

OkとErrの2つのバリアントで構成されるResult型の基本図解

ここからは、Rustのエラーハンドリングを支える中心的な道具、Result<T, E>を解剖していきます。
型としての中身は非常に小さく、それゆえに扱い方の幅が広い型です。
まずは構造から確認し、その上で分解と落とし穴までを一気に把握しましょう。

Resultの定義と2つのバリアント

Resultは、Rustの標準ライブラリで以下のように定義されています。

enum Result<T, E> {
    Ok(T),
    Err(E),
}

これは2つのバリアントを持つ代数的数据型(ADT)、つまり「T型の値を持つOkか、E型の値を持つErrのどちらか」という直和の表現です。
Tは成功時のペイロード、Eは失敗時のエラー情報をそれぞれ表します。

実世界では、この組み合わせがそのまま失敗の文脈を表現します。

  • ファイル読み込み: Result<String, io::Error>
  • 整数パース: Result<i32, std::num::ParseIntError>
  • DB問い合わせ: Result<User, DbError>

つまり「何を返したい成功値」と「どんな失敗があり得るか」が、シグネチャを読んだ瞬間に読者に伝わります。
これがResultの構造的な強みです。

matchとif letで結果を分解する

Resultを手にしたら、次はその中身を取り出す分解(destructuring)です。
最も基本になるのはmatchです。

match read_config() {
    Ok(cfg) => start_app(cfg),
    Err(e)  => log_error_and_exit(&e),
}

matchは網羅的(exhaustive)で、OkとErrの両方を必ず扱う必要があります。
どちらかのパターンを書き忘れた時点でコンパイラが警告してくれるため、「エラーをうっかり忘れる」という古典的なバグを型レベルで潰せます。

一方、成功側だけに興味があるケースはif letが簡潔です。

if let Ok(cfg) = read_config() {
    start_app(cfg);
}

読みやすさの観点では、Errの処理を上位の呼び出し側に任せる場面――たとえば呼び出し元がすでに?で伝播する前提に立っているとき――で、if letは適切な選択肢になります。

unwrapとexpectの落とし穴

Resultを扱う最短の方法が、unwrapとexpectです。

let cfg = read_config().expect("config should be present");
let s   = read_config().unwrap();

どちらも内部的にはErrの場合にpanic!を発生させます。
expectはメッセージ付きでパニックする点が異なりますが、Errを握り潰してクラッシュに変換するという挙動は共通です。

  • プロトタイプやテストでは便利
  • 一方、本番コードでは「想定外」として即座にクラッシュするため、回復の余地を奪う
  • ライブラリ作者が気軽に使うと、呼び出し側が必要なエラー情報を得られなくなる

unwrapとexpectは設計上の境界――「ここでは失敗しないことが契約である」という不変条件が成り立つ場所にだけ置くべきです。
「よくわからないからとりあえずunwrap」という書き方は、型が保証していた安全性を自ら手放す行為に他なりません。

次の章では、この?演算子の内部動作と、エラー伝播のベストプラクティスを掘り下げていきます。

?演算子の仕組みとエラー伝播のベストプラクティス

?演算子がエラー伝播を行う仕組みを表現したRustコード例のイメージ

Resultを手にしたら、次に覚えたいのが?演算子です。
これは失敗を呼び出し側に自動で持ち上げる糖衣構文で、エラーハンドリングを驚くほど短く記述できます。
しかし、短く書けることと正しく理解して書くことは別の話。
まずは?が内部で何をしているかを分解し、その上で使い所の判断軸まで踏み込みます。

?演算子が内部で行う3つの処理

?演算子は見た目こそ1文字ですが、内部的には3つの仕事をしています。
例として、次のコードを考えてみます。

fn count_lines(path: &str) -> Result<usize, MyError> {
    let text = std::fs::read_to_string(path)?;
    Ok(text.lines().count())
}

この?は、おおむね次のmatchに展開できます。

fn count_lines(path: &str) -> Result<usize, MyError> {
    let text = match std::fs::read_to_string(path) {
        Ok(v)  => v,
        Err(e) => return Err(e.into()),
    };
    Ok(text.lines().count())
}

つまり?は、

  1. Resultをmatchで分解する
  2. Errなら現在の関数から早期returnする
  3. その際にFrom::fromでエラー型を変換する

という3つをまとめて実行しています。
「失敗を呼び出し側に渡す」コードが1文字で書けるのは、この3ステップが暗黙的に束ねられているからです。

From変換でエラー型を自動変換する

?の振る舞いの中で見落としやすいのが、Err(e.into())の.into()です。
?は関数の戻り値型がResult<T, MyError>であっても、内部で発生したio::Errorを自動でMyErrorに変換してからreturnします。

この自動変換を支えているのがFromトレイトです。
エラー型側でFrom<io::Error> for MyErrorを実装しておくと、?が内部でMyError::from(io_error)を呼んでくれます。

#[derive(Debug)]
enum MyError {
    Io(io::Error),
    Parse(toml::de::Error),
}

impl From<io::Error> for MyError {
    fn from(e: io::Error) -> Self { MyError::Io(e) }
}
impl From<toml::de::Error> for MyError {
    fn from(e: toml::de::Error) -> Self { MyError::Parse(e) }
}

これにより、関数内でio::Errorとtoml::de::Errorの両方が混在しても、?一発で自分のMyErrorに詰めて返せます。
呼び出し側の型と内部の型を、Fromを接点に翻訳する――これがRustのエラー伝播の核心です。

?演算子を使うとき・使わないときの判断軸

?は便利ですが、いつでも最良の選択とは限りません。
使うべき場面と、避けるべき場面を意識的に分けることが、可読性の高いコードにつながります。

?が適しているのは、失敗時に同じ動作(早期return+型変換)をさせたい場面です。
たとえば設定ファイルの読み込み・パース・バリデーションを素直に通すだけの関数では、?を並べるだけで済みます。

fn load(path: &str) -> Result<Config, MyError> {
    let text = std::fs::read_to_string(path)?;
    let cfg: Config = toml::from_str(&text)?;
    cfg.validate()?;
    Ok(cfg)
}

一方、?を避けた方が良いのは、失敗に対して特別な処理をしたい場面です。
「ファイルが存在しない場合は空の設定として扱う」「特定のパースエラーなら警告だけ出して続行する」といった分岐は、matchで明示的に書く方が意図が伝わります。

fn load(path: &str) -> Result<Config, MyError> {
    let text = match std::fs::read_to_string(path) {
        Ok(v) => v,
        Err(e) if e.kind() == io::ErrorKind::NotFound => String::new(),
        Err(e) => return Err(MyError::Io(e)),
    };
    let cfg: Config = toml::from_str(&text)?;
    Ok(cfg)
}

判断軸をまとめると、

  • 失敗を呼び出し側にそのまま伝えたい → ?を使う
  • 失敗時に文脈を足したい/分岐したい → matchかif letで書く

という基準になります。
「短く書けるから?」ではなく、意図に合っているかどうかで選んでください。

次の章では、このエラー型をクレート・モジュールの単位でどう設計するかを掘り下げていきます。

カスタムエラー型の設計 ― クレート・モジュールの粒度で分ける

カスタムエラー型を階層化・モジュール化する設計パターンのイメージ

Result<T, E>のEに何を置くかは、コードの可読性と拡張性に直結する設計判断です。
「とりあえずString」でも動きますが、それでは型が与えてくれた強みを自ら捨てることになります。
ここでは、そのEを自分の手で設計するときの軸を整理します。

単一エラー型 vs 複数エラー型の使い分け

最初の分岐点は、1つのクレートに対してエラー型を1つにするか複数にするかです。

戦略 メリット デメリット
単一エラー型 APIシグネチャが単純になり、呼び出し側の認知負荷が低い 内部の失敗種類が雑多になると、肥大化や誤ったグルーピングが起きる
複数エラー型 失敗の構造を素直に表現でき、Fromで束ねられる 設計の初期コストが高く、レイヤ設計が曖昧だと破綻しやすい

経験則としては、「公開APIの責務がはっきりしているクレートでは1つ、内部モジュールが複数に分かれるならそれに対応して複数」が穏当な出発点です。
小さなバイナリではanyhow::Errorで全部まとめてしまい、ライブラリ境界ではthiserrorで型を定義する、というのが後述する実用的な落とし所になります。

thiserrorでボイラープレートを削減する

自前のエラー型を素朴にenumで定義すると、Display実装やErrorトレイト実装が毎回繰り返され、コードの主成分をエラーのグルーが占めてしまいがちです。
ここでthiserrorのderiveマクロを使うと、宣言的に書けます。

use thiserror::Error;

#[derive(Debug, Error)]
pub enum DataStoreError {
    #[error("connection failed: {0}")]
    Connection(#[source] io::Error),
    #[error("invalid key: {0}")]
    InvalidKey(String),
    #[error("not found")]
    NotFound,
}

#[error("...")]でDisplay出力、#[source]で原因エラーの連鎖を指定できます。
「エラー定義は宣言、振る舞いは標準トレイトに委譲」という方針で、エラー定義の見通しを大幅に改善できます。

From実装でエラー型を階層化する

クレートやサービスが大きくなってくると、下位層のエラー型をそのまま上位層に露出させたくない場面が出てきます。
下位層の実装詳細を隠蔽しつつ、情報を保つにはFromで階層を変換します。

impl From<RepositoryError> for ServiceError {
    fn from(e: RepositoryError) -> Self {
        ServiceError::Repository(Box::new(e))
    }
}

ここでBox<dyn Error + Send + Sync>に変換しておくと、異なる下位エラーを共通の「原因」型として束ねられます。
呼び出し側ではServiceErrorだけ見ればよく、必要ならsource()で掘り下げて根本原因に到達できる。
この抽象化と情報保全の両立が、Fromによる階層化の価値です。

エラー型に含めるべき情報 ― コンテキスト・原因・位置

最後に、エラー型にどんな情報を持たせるべきかという話をします。
型シグネチャは呼び出し側に「どんな失敗があり得るか」を伝える唯一の窓ですから、ここに十分な文脈を乗せるのは設計者としての責務です。

情報の種類 役割 具体例
コンテキスト 失敗が起きた状況や対象 ファイルパス、ユーザID、リクエストURL
原因(source) 根本原因となったエラー io::Error、ParseErrorそのもの
位置 発生箇所のヒント 行番号、列番号、トレースへの手がかり
#[derive(Debug, Error)]
#[error("failed to parse {path} at line {line}")]
pub struct ParseError {
    pub path: PathBuf,
    pub line: usize,
    #[source]
    pub cause: Box<dyn Error + Send + Sync>,
}

「String1個で十分」という設計は、最初の1週間は速く、半年後に爆発します。
失敗を後でデバッグする誰か――多くの場合、未来の自分のために、エラー型に必要な情報を設計してください。

次の章では、このカスタムエラー型を支えるthiserrorとanyhowの実践的な使い分けを見ていきます。

thiserrorとanyhowの使い分け ― ライブラリとアプリの境界

thiserrorとanyhowの用途の違いをフローチャートで対比した画像

前章でthiserrorを使ったエラー型定義を紹介しました。
一方、Rustの実務ではanyhowというクレートもよく登場します。
この2つは対立するものではなく、使われる場面が違うものです。
両者の役割と境界の見極め方を、ここで一気に整理します。

ライブラリはthiserror、アプリはanyhowという基本原則

最も広く支持されている指針は、「ライブラリはthiserror、アプリケーションはanyhow」というものです。

観点 ライブラリ(thiserror) アプリケーション(anyhow)
エラー型の扱い 公開APIの一部として厳密に定義 anyhow::Errorにまとめて持てば十分
呼び出し側の扱い matchで分岐して回復したい ?で流して最後にログや表示で処理
情報の粒度 構造化されたフィールドが要る 人間に読める文字列で十分

ライブラリ作者は「この失敗を呼び出し側がどう処理するか」を意識する必要があります。
一方、アプリケーションのmainに近い層では「最終的にログに出してプロセスを止める」のが目的なので、エラーを構造化しても使い道がない場面が多い。
この責務の違いが、thiserrorとanyhowのすみ分けを自然に決めます。

anyhow::Errorとanyhow::Resultの実装パターン

anyhowは、任意のErrorトレイト実装を包むことができる型消去のエラーラッパーを提供します。
Result<T, anyhow::Error>のエイリアスとしてanyhow::Result<T>も用意されており、main関数でも気軽に使えます。

use anyhow::{Context, Result};

fn main() -> Result<()> {
    let cfg = load_config("app.toml")
        .with_context(|| "loading app config")?;
    run(cfg)
        .with_context(|| "running application")?;
    Ok(())
}

Context::contextとwith_contextは、失敗時にどこで何をしたかったかを文字列で付け足すための仕組みです。
thiserrorが構造化を担うのに対し、anyhowのContextは人間のためのラベル付けを担う。
この対称構造が、thiserrorとanyhowを補完的に使える理由になっています。

境界でanyhowからthiserrorへ変換する

「アプリケーションはanyhow」と書いたものの、外部に公開する境界――たとえばWebAPIのレスポンスやライブラリ関数――では、構造化されたエラー型を返したい場面が出てきます。
そのときは境界でFromを使ってanyhow::Errorを具体的な型に変換します。

#[derive(Debug, thiserror::Error)]
pub enum ApiError {
    #[error("not found")]
    NotFound,
    #[error("internal error")]
    Internal(#[source] anyhow::Error),
}

impl From<anyhow::Error> for ApiError {
    fn from(e: anyhow::Error) -> Self {
        ApiError::Internal(e)
    }
}

こうしておくと、内部ではanyhowの便利さを享受しつつ、外部に対してはApiErrorという安定した契約を返せます。
境界をまたいだ瞬間に「曖昧な失敗」を構造化された失敗に変換する――このパターンを覚えておくと、設計の選択肢が大きく広がります。

「ライブラリは型を、アプリは流れを」というのが、合言葉のように使える指針です。

次の章では、panic!・unwrap・expectが許される境界線の引き方を扱います。

panic・unwrap・expect ― 設計上「許される」境界線の引き方

panicとunwrapの許容境界をフローチャートで示した設計ガイド画像

Resultを扱えるようになっても、実際のコードではunwrapやexpectを完全になくすのは難しい場面があります。
問題は「使うか使わないか」ではなく、どこで使うべきかを判断できるかどうかにあります。
panic!の立ち位置を整理し、「許される」境界線を引いていきます。

プロトタイプでは許されるpanic

まず大前提として、プロトタイピングや学習目的のコードではunwrap/expectは積極的に使ってよいです。

fn prototype_main() {
    let cfg = load_config("app.toml").unwrap();
    run(cfg);
}

ここでunwrapしているのは「失敗したら即座にバグに気づきたい」という意図であり、本番運用を見据えたコードではありません。
失敗が起きたとき、原因のスタックトレースと共に即座に落ちるというのは、開発時のフィードバック速度を最優先にする場面では合理的な選択です。

ただし、プロトタイプを卒業する段階では?への置換とResultへの型付けを必ず行ってください。
「unwrapが散在するプロトタイプがそのまま本番に出る」というのが、最も多く報告されるRustあるあるのひとつです。

到達不能コードをpanic!で表現する

もうひとつ、panic!が積極的に許される場面があります。
それは論理的に発生しないはずのケースを明示したいときです。

fn describe_byte(b: u8) -> &'static str {
    match b {
        0 => "zero",
        1 => "one",
        _ => unreachable!("u8 only carries 0 or 1 here"),
    }
}

unreachable!やtodo!は、コンパイラに対する「ここには来ないはず」というアサーションです。
型システムの表現力と現実の制約がずれる境界――たとえば「外部APIから返ってきた値はある決まった値域に絞られているはず」といった外部の不変条件を扱うとき、panic!で「逸脱したら即座に発見する」と宣言するのは正当な使い方です。

ライブラリAPIでpanicを呼び出してはいけない理由

逆に、ライブラリAPIでpanic!を呼んではいけないのは、Rustの文化的にもっとも強く共有されているルールのひとつです。

// 悪い例:空入力で呼び出し側を地獄に落とす
pub fn first_item(items: &[Item]) -> Item {
    items.first().unwrap()
}

// 良い例:失敗を呼び出し側に返す
pub fn first_item(items: &[Item]) -> Option {
    items.first().cloned()
}

理由はシンプルで、panic!は呼び出し側に「回復する権利」を与えないからです。
ライブラリ利用者は、自分の文脈で「空の場合はデフォルトを返す」「別のデータソースにフォールバックする」「ユーザに再入力を促す」といった判断をしたくても、panic!された瞬間にその選択肢がすべて消えます。

判断軸を表に整理します。

場面 panic/unwrap Result 主な理由
プロトタイプ・学習 適 過剰 フィードバック速度を優先
到達不能コード 適 過剰 論理的に発生しない前提を表明
ライブラリ公開API 不適 必須 呼び出し側の回復手段を奪う
アプリケーション境界 場合による 推奨 致命時はpanic、それ以外はResult

panic!を「乱用しない」ではなく、「許される場所をひとつずつ明示的に選ぶ」。
この姿勢が、Rustの型システムが持つ安全性を最後まで使い切るコツです。

次の章では、実務で特に踏みやすいアンチパターンとその回避策を見ていきます。

実務で陥るアンチパターンと回避策

Rustのエラーハンドリングで陥りがちなアンチパターンと回避策の一覧

ここまでで紹介してきた設計原則を押さえていても、実務の現場では「とりあえず動く」コードが書かれる圧力がかかります。
この章では、特にRustプロジェクトで頻出する3つのアンチパターンと、それぞれの正しい逃げ方を整理します。

Boxに逃げるな

Rust初心者に最も多いのが、Box<dyn std::error::Error>をResultの戻り値型にしてしまうアンチパターンです。

// アンチパターン:型情報がすべて消える
fn read_file(path: &str) -> Result<String, Box<dyn std::error::Error>> {
    let text = std::fs::read_to_string(path)?;
    Ok(text)
}

確かにこの形はコンパイルが通ります。
しかし、Box<dyn Error>は具体的なエラー型を完全に消去してしまうため、呼び出し側は「中身がio::Errorなのかtoml::de::ErrorなのかParseIntErrorなのか」を知ることができません。
ダウンキャストすれば取り出せますが、本番コードでそこまでする人は稀でしょう。

// 改善版:独自のエラー型を定義して`From`で詰める
fn read_file(path: &str) -> Result<String, AppError> {
    let text = std::fs::read_to_string(path)?;
    Ok(text)
}

AppErrorをthiserrorで定義し、From<io::Error>を実装しておけば、?一発でAppError::Ioに包まれます。
型情報を持つエラーは、デバッグ可能性と回復可能性の両方を同時に引き上げる――これが、Box<dyn Error>を避ける最大の理由です。

エラーを握り潰すsilent failure

次に多いのが、失敗を検知しても何もしないコードです。

// アンチパターン:失敗が完全に消える
let _ = open_log_file();

// または
if let Err(_) = open_log_file() {
    // 握り潰し
}

「ログが開けなくてもアプリ自体は動くから」という意図で書かれることが多いのですが、エラーを無視するという行為は、設計判断ではなくただの未決着です。
後で「ログが記録されない」「分析データが空になる」となって、原因調査が泥沼になります。

改善の方向性は2つあります。

// 方向性1:少なくとも警告をログに出す
if let Err(e) = open_log_file() {
    eprintln!("warning: log open failed: {e}");
}

// 方向性2:失敗を呼び出し側に返す
fn init() -> Result<(), AppError> {
    open_log_file()?;
    Ok(())
}

「無視していい失敗」と「無視してはいけない失敗」を区別し、後者を必ず可視化してください。
沈黙する失敗は、最も発見しにくいバグになります。

文字列でエラーを返すな ― 型情報を持たせる

最後にもうひとつ。
Result<T, String>やResult<T, &'static str>のように、エラーを素の文字列で返すアンチパターンもよく見ます。

// アンチパターン:構造が文字列に溶け出す
fn parse_port(s: &str) -> Result<u16, String> {
    s.parse().map_err(|e| format!("parse failed: {e}"))
}

これでは「parse failed: ...というメッセージの構造」がコードに現れません。
呼び出し側がメッセージで分岐しようとすると、starts_with("parse failed")のような不安定な文字列マッチが必要になります。

// 改善版:エラー型で構造を持たせる
#[derive(Debug, thiserror::Error)]
#[error("invalid port: {0}")]
struct PortParseError(String);

fn parse_port(s: &str) -> Result<u16, PortParseError> {
    s.parse().map_err(PortParseError)
}

文字列は人間のため、エラー型はコンピュータのためにある――この棲み分けを意識すると、エラー定義の粒度が劇的に改善します。
機械可読なエラー型を基盤に、そのDisplay実装として人間可読な文字列を整える、という順番が推奨されます。

次の最終章では、ここまでの議論全体を「Result型を負担から表現に変える」という視点から総括します。

まとめ ― Result型を「負担」から「表現」に変えるために

RustのResult型を負担から表現へと変えるための要点をまとめたヒーロー画像

ここまで、Result<T, E>を中心に据えてRustのエラーハンドリングを整理してきました。
最後に、記事を貫くテーマを一度まとめておきます。

失敗を値として扱う ― 一貫した哲学

最初に提示した「失敗を値として扱う」という設計哲学は、本記事全体の座標軸でした。
例外やpanicの制御フロー的な失敗と決別し、失敗を第一級の値として型の上に並べる――この判断が、Rustの他のすべてのエラーハンドリング機能の土台になっています。

この哲学に乗ると、自然と次の原則が従います。

  • 型で失敗を語る: シグネチャにResult<T, E>が並ぶことで、設計の意図がそのままドキュメントになる
  • コンパイル時に強制する: 取りこぼしがビルドエラーとして現れる
  • 失敗を値で合成する: ?演算子やFromで、回復と抽象化を等価に行える

判断軸の早見表

記事中で触れた設計判断を、簡潔な早見表としてまとめます。

場面 推奨 理由
ライブラリAPI thiserrorで構造化 呼び出し側の回復手段を残す
アプリケーション内部 anyhow+Context 失敗を流しつつラベルを残す
境界(公開API・CLI終了点) anyhow→thiserrorに変換 曖昧さを構造に変換する
プロトタイプ・到達不能 unwrap/expect/unreachable! フィードバック速度を最優先
エラー情報の表現 エラー型+Display実装 機械可読を基盤に人間可読を整える

この表をそのまま暗記する必要はありません。
迷ったら「失敗を呼び出し側に返す権利を奪っていないか」を自分に問いかけてください。
その一言が、ほとんどの設計判断の指針になります。

負担ではなく表現へ

最後に、タイトルに戻ります。
コードの進化を見れば、本記事を読み終えたあなたが目指す姿は明らかです。

// Before: panic with String error
fn read_name(path: &str) -> String {
    std::fs::read_to_string(path).unwrap().trim().to_string()
}

// After: typed result with custom error
fn read_name(path: &str) -> Result<String, AppError> {
    let s = std::fs::read_to_string(path)?;
    Ok(s.trim().to_string())
}

シグネチャが「成功か失敗か」「どんな失敗か」を語り、関数の本体は失敗時の責務を呼び出し側に委ねる――この対称性が、Rustらしいエラーハンドリングの理想形です。

panicが消えて、落ち方が「バグ」か「想定外」かで分類されるようになった。
Stringエラーが消えて、機械可読なエラー型で失敗の構造が表せるようになった。
ライブラリ境界で安定した契約を返せるようになり、呼び出し側が安心して使えるようになった。
Box<dyn Error>に逃げる安易さが消え、設計の粒度を上げる覚悟が得られた。

これらはすべて、エラーハンドリングを「特別な注意」から「通常のプログラミングの一部」へと引き戻した結果です。
Resultを単なる型としてではなく、失敗を通じて設計意図を伝える言語として使うこと。
そこに「負担」から「表現」への転換があります。

明日から書くコードで、unwrapをひとつ減らすところから始めてみてください。
失敗との向き合い方は、確実に変わっていきます。

コメント

タイトルとURLをコピーしました