TypeScriptで堅牢なアプリケーションを構築する際、エラーハンドリングは避けて通れない課題です。特に、try...catchブロックの乱用やany型のエラー処理は、コンパイル時にエラーの存在を把握できず、実行時まで問題が顕在化しないという「型安全性の喪失」を招きがちです。これにより、デバッグが困難になったり、予期せぬ障害につながるリスクを抱えてしまいます。

この記事では、TypeScriptの型安全なエラーハンドリングを次のレベルに引き上げるライブラリ「Effect（旧Effect-TS）」に焦点を当てます。Effectを活用することで、どのようにしてこれらの課題を解決し、より堅牢で保守性の高いコードを構築できるのか、具体的なコード例を交えながら徹底解説します。この記事を読めば、TypeScriptプロジェクトにおけるエラーハンドリングのベストプラクティスを理解し、実務で直面する複雑なエラー伝播やカスタムエラークラスの設計といった問題を、型安全に解決するための強力な武器を手に入れられるでしょう。

TypeScriptのエラーハンドリングが抱える課題

まず、TypeScriptにおける従来のエラーハンドリング、特にtry...catch構文やPromiseのcatchが抱える課題を整理します。多くのエンジニアがここでつまずき、結果として予期せぬバグや保守性の低下を招いています。

`try...catch`と`unknown`型エラーの問題点

TypeScriptでエラーを捕捉する際、catch (e)で捕捉されるeの型はデフォルトでunknownです。これはTypeScriptが、tryブロック内でどのような型のエラーがthrowされるかを知らないためです。結果として、エラーの内容を安全に利用するためには型ガードや型アサーションが必要となり、ボイラープレートが増えるだけでなく、型安全性が損なわれるリスクがあります。

try {
  // 何らかの処理でエラーが発生する可能性
  throw new Error("Something went wrong");
} catch (e) {
  // eはunknown型
  if (e instanceof Error) {
    console.error(`Caught an Error: ${e.message}`);
  } else {
    console.error(`Caught an unknown error: ${e}`);
  }
}

このアプローチでは、関数がどのようなエラーを返す可能性があるかを関数のシグネチャから読み取ることができません。呼び出し元は、その関数がどのようなエラーをthrowするのかをドキュメントや実装を読んで確認する必要があり、見落としによるバグの温床となります。

非同期処理におけるエラー伝播の複雑さ

Promiseベースの非同期処理では、エラーはrejectとして伝播します。複数の非同期処理が連鎖する場合、どこの処理でどのようなエラーが発生したのかを追跡するのが困難になることがあります。また、async/await構文を使っても、結局はtry...catchの課題に直面します。

async function fetchData(): Promise<string> {
  // 外部API呼び出しなど
  if (Math.random() < 0.5) {
    throw new Error("Network error");
  }
  return "Data fetched";
}

async function processData() {
  try {
    const data = await fetchData();
    console.log(data);
  } catch (e) {
    // ここでもeはunknown
    if (e instanceof Error) {
      console.error(`Failed to process data: ${e.message}`);
    }
  }
}

processData();

このような状況では、エラーが発生した際に、どのレイヤーでエラーが発生し、どのようなコンテキストだったのかという情報が失われがちです。

Effect-TSとは？型安全なエラーハンドリングの救世主

これらの課題に対する強力な解決策が、TypeScript向けの関数型プログラミングライブラリであるEffectです。Effectは、成功時の値だけでなく、発生しうるエラーの型、さらには必要な環境の型までをも型システムに組み込むことで、コンパイル時により堅牢なプログラムを構築することを可能にします。

Effectのコア抽象: `Effect<R, E, A>`

Effectの中心となるのはEffect<R, E, A>型です。

R (Requirements): そのEffectを実行するために必要な依存性（環境）の型。
E (Error): そのEffectが失敗した場合に返す可能性のあるエラーの型。
A (Success): そのEffectが成功した場合に返す値の型。

このE型が、TypeScriptの型システムにエラー情報を組み込む鍵となります。これにより、関数がどのようなエラーを返す可能性があるかを、関数のシグネチャから一目で把握できるようになります。

import { Effect } from "effect";

// このEffectは、成功時にstringを返し、失敗時にError型のエラーを返す可能性がある
const myEffect: Effect<never, Error, string> = Effect.fail(new Error("Failed!"));

Failures vs Defects: エラーの二種類

Effectはエラーを「予期されるエラー（Failure）」と「欠陥（Defect）」の2種類に区別します。

Failure（予期されるエラー）: ビジネスロジック上で回復可能なエラー（例: "ユーザーが見つかりません"、"入力値が不正です"）。これらはEffect.failで作成され、E型として型レベルで追跡されます。
Defect（欠陥）: プログラムのバグや予期しないシステムエラー（例: ゼロ除算、nullへのアクセス、throwされた捕捉されない例外）。これらはEffect.dieまたは捕捉されない例外で作成され、E型には現れず、通常はプログラムを終了させます。

この区別により、開発者は回復可能なエラーと、直ちに修正すべきバグを明確に区別して扱えるようになります。

Effect-TSを使った型安全なエラーハンドリングの実践

ここからは、Effectを使った具体的なエラーハンドリングの実装方法を見ていきましょう。

Effectのインストールと設定

まず、Effectライブラリをプロジェクトにインストールします。

npm install effect

tsconfig.jsonでは、strictモードを有効にすることが推奨されます。

{
  "compilerOptions": {
    "strict": true,
    "target": "es2022",
    "module": "commonjs", // または "esnext" など
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "skipLibCheck": true
  }
}

カスタムエラークラスの定義と`Data.TaggedError`

Effectでは、Data.TaggedErrorを使用してカスタムエラー型を定義することがベストプラクティスです。これにより、エラーに自動的に_tagフィールドが追加され、コンパイル時に異なるエラー型を識別し、Effect.catchTagのような関数で特定のタイプのエラーを型安全に処理できます。

import { Data } from "effect";

// HttpErrorは_tag: "HttpError"を持つ
class HttpError extends Data.TaggedError("HttpError")<{ message: string }> {}

// ValidationErrorは_tag: "ValidationError"を持つ
class ValidationError extends Data.TaggedError("ValidationError")<{ field: string, reason: string }> {}

// これにより、エラーの種類を型レベルで識別できるようになる
type MyErrors = HttpError | ValidationError;

`Effect.gen`と`yield*`によるエラー生成

Effect.genは、ジェネレーター関数とyield*構文を使用することで、非同期処理やエラーハンドリングを含む複雑なロジックを、命令的で読みやすいスタイルで記述するための強力なコンビネータです。Effect.failを使って、定義したカスタムエラーを発生させます。

import { Effect, Random } from "effect";
// ... (HttpErrorとValidationErrorの定義は省略)

const fetchData = Effect.gen(function* () {
  const n = yield* Random.next; // 0から1の乱数を生成
  if (n < 0.5) {
    // HttpErrorを発生させることを型レベルで宣言
    return yield* Effect.fail(new HttpError({ message: "Network request failed" }));
  }
  return "Data fetched successfully";
});

const validateInput = (input: string) => Effect.gen(function* () {
  if (input.length < 5) {
    // ValidationErrorを発生させることを型レベルで宣言
    return yield* Effect.fail(new ValidationError({ field: "input", reason: "Input too short" }));
  }
  return `Valid input: ${input}`;
});

// fetchDataのE型はHttpError
type FetchDataError = Effect.Error<typeof fetchData>; // HttpError

// validateInputのE型はValidationError
type ValidateInputError = Effect.Error<ReturnType<typeof validateInput>>; // ValidationError

複数のEffectとエラーの自動結合

複数のEffectをyield*で合成すると、それらのEffectが持つエラー型はTypeScriptのユニオン型として自動的に結合されます。これにより、プログラム全体で発生しうるすべてのエラーを正確に把握できます。

import { Effect, Console } from "effect";
// ... (fetchData, validateInput, HttpError, ValidationErrorの定義は省略)

const program = Effect.gen(function* () {
  const data = yield* fetchData; // E型にHttpErrorが追加される
  yield* Console.log(data);

  const validated = yield* validateInput("short"); // E型にValidationErrorが追加される
  yield* Console.log(validated);
});

// programのE型は HttpError | ValidationError となる
type ProgramErrors = Effect.Error<typeof program>; // HttpError | ValidationError

このProgramErrors型は、programが失敗する可能性のあるすべてのエラー型を網羅していることをコンパイル時に保証します。

`Effect.catchTag`と`Effect.catchAll`によるエラーハンドリング

Effectは、エラーハンドリングのための多様なコンビネータを提供します。

Effect.catchTag(tag, handler): 特定の_tagを持つエラーを捕捉し、処理します。捕捉されたエラーは、そのEffectのE型から取り除かれ、型安全に回復できます。
Effect.catchAll(handler): それまでに処理されなかったすべてのエラーを捕捉します。通常は最終的なエラーハンドリング層で使用します。

import { Effect, Console, Random, Data } from "effect";

// 1. カスタムエラー型の定義
class HttpError extends Data.TaggedError("HttpError")<{ message: string }> {}
class ValidationError extends Data.TaggedError("ValidationError")<{ field: string, reason: string }> {}

// 2. 失敗する可能性のあるEffectの作成
const fetchData = Effect.gen(function* () {
  const n = yield* Random.next;
  if (n < 0.5) {
    return yield* Effect.fail(new HttpError({ message: "Network request failed" }));
  }
  return "Data fetched successfully";
});

const validateInput = (input: string) => Effect.gen(function* () {
  if (input.length < 5) {
    return yield* Effect.fail(new ValidationError({ field: "input", reason: "Input too short" }));
  }
  return `Valid input: ${input}`;
});

// 3. 複数のEffectを合成し、エラーを自動的に追跡し、ハンドリング
const programWithHandling = Effect.gen(function* () {
  const data = yield* fetchData;
  yield* Console.log(data);

  const validated = yield* validateInput("short");
  yield* Console.log(validated);
}).pipe(
  // HttpErrorのみを捕捉し、回復する
  Effect.catchTag("HttpError", (error) =>
    Console.error(`HTTP Error: ${error.message}`).pipe(
      // エラーから回復し、成功値を返す。
      // この時点のEffectのE型からはHttpErrorが取り除かれる。
      Effect.succeed("Recovered from HTTP error with default data")
    )
  ),
  // 残りのすべてのエラー（この場合はValidationError）を捕捉
  Effect.catchAll((error) =>
    Console.error(`An unexpected error occurred: ${JSON.stringify(error)}`).pipe(
      // プログラムを最終的に失敗させるEffectを返す
      Effect.fail(new Error("Program terminated due to unhandled error"))
    )
  )
);

// 4. Effectプログラムの実行
Effect.runPromise(programWithHandling).then(console.log).catch(console.error);

このコードでは、fetchDataとvalidateInputがそれぞれ異なるエラーを発生させる可能性がありますが、programWithHandlingのパイプラインでHttpErrorをcatchTagで捕捉し、回復処理（デフォルト値を返す）を行っています。その結果、programWithHandlingのE型からはHttpErrorが除外され、残りのValidationErrorがcatchAllで処理されます。これにより、どのエラーがどこで処理されるべきか、コンパイル時に明確になります。

Promiseベースのコードとの相互運用

既存のPromiseベースのAPIとEffectを組み合わせる場合、Effect.tryPromiseが非常に役立ちます。これにより、Promiseがrejectする可能性のあるunknown型のエラーを、Effectの型安全なエラー型に変換できます。

import { Effect } from "effect";

// 既存のPromiseベースのAPI (エラーはunknown型)
const oldApiCall = (): Promise<string> =>
  new Promise((resolve, reject) => {
    if (Math.random() < 0.5) {
      reject("Legacy API failed!"); // string型でrejectされることもあり得る
    } else {
      resolve("Legacy data");
    }
  });

// カスタムエラーを定義
class LegacyApiError extends Data.TaggedError("LegacyApiError")<{ originalError: unknown }> {}

// PromiseをEffectに変換
const effectFromPromise = Effect.tryPromise({
  try: () => oldApiCall(),
  // Promiseがrejectした場合のunknown型エラーをLegacyApiErrorに変換
  catch: (e) => new LegacyApiError({ originalError: e }),
});

// effectFromPromiseのE型はLegacyApiError
type LegacyEffectError = Effect.Error<typeof effectFromPromise>; // LegacyApiError

Effect.runPromise(effectFromPromise.pipe(
  Effect.catchTag("LegacyApiError", (e) =>
    Effect.succeed(`Recovered from legacy API error: ${JSON.stringify(e.originalError)}`)
  )
)).then(console.log).catch(console.error);

Effect-TS導入時のハマりどころと回避策

Effectは強力ですが、独特のパラダイムを持つため、導入時にはいくつかのハマりどころがあります。

`Effect.fail`ではなく`throw`を使ってしまう

ハマりどころ: Effectのコンテキスト内でthrow new Error()を使ってしまうと、そのエラーはE型として追跡されず、「Defect」として扱われます。結果として、型安全なエラーハンドリングの恩恵を受けられず、プログラムが予期せず終了する可能性があります。
回避策: Effectのコンテキストでは、常にreturn yield* Effect.fail(new MyCustomError())のようにEffect.failを使用します。既存のthrowベースのコードをラップする場合は、前述のEffect.tryPromiseやEffect.tryを利用してEffectのエラーに変換します。

エラー型のユニオンの肥大化とハンドリング漏れ

ハマりどころ: 複数のEffectを合成すると、エラー型が自動的にユニオン型として結合されます。これにより、エラー型が複雑になり、catchAllで一括処理する際に、特定のエラータイプのハンドリングを漏らす可能性があります。特に、catchAllで回復する際に、本来処理すべきエラーをunknownとして扱ってしまうと、型安全性が損なわれます。
回避策: Data.TaggedErrorを使用して、明確なタグを持つカスタムエラークラスを定義し、Effect.catchTagで特定のタグを持つエラーを型安全に処理します。エラー型が肥大化しすぎないように、関連するエラーをグループ化することも検討し、できるだけ上位のコンポーネントでエラーを吸収・変換して下位に伝播させないように設計します。

Promiseベースのコードとの相互運用時のエラー変換

ハマりどころ: 既存のPromiseベースのライブラリやAPIをEffectと組み合わせる際、PromiseがrejectするエラーはTypeScriptではunknown型として扱われるため、Effectの型安全なエラーハンドリングに持ち込む際に型情報が失われがちです。
回避策: Effect.tryPromiseを使用し、catchオプションでPromiseがrejectする可能性のあるエラーを明示的にEffectのエラー型にマッピングします。これにより、型安全性を維持しつつ、既存のコードと連携できます。

Effect-TSにおけるベストプラクティスとトレードオフ

Effectを効果的に活用するためには、いくつかのベストプラクティスと、その導入がもたらすトレードオフを理解しておくことが重要です。

ベストプラクティス

Data.TaggedErrorによるカスタムエラーの定義: 型安全なエラーハンドリングの基盤です。明確なタグを持つことで、Effect.catchTagを最大限に活用できます。
Effect.genとyield*の活用: 複雑な非同期処理やエラーパスを、命令的かつ読みやすいスタイルで記述できます。
エラーメッセージの明確化: エラーメッセージには、何が問題だったのか、なぜ発生したのか、解決策や代替アクションを明確に記述し、デバッグに役立つコンテキスト情報を含めます。
Layerによる依存性注入: EffectのLayerモジュールを活用することで、依存関係をモジュール化し、テスト容易性と再利用性を高めます。
段階的な導入: 既存のコードベースにEffectを導入する場合は、Effect.tryPromiseで既存の非Effect APIをラップし、Effect.runPromiseでEffectプログラムを実行することで、小さな部分から段階的に導入できます。

トレードオフ

学習曲線: Effectは強力ですが、関数型プログラミングの概念やEffect特有のパターン（Effect型、Layer、Fiberなど）に慣れるまでに steep な学習曲線があります。初期の学習コストは高くなる可能性があります。
コードの冗長性: 従来のtry/catchやPromiseベースのエラーハンドリングと比較して、Effectのパターンはより明示的であるため、コードが冗長になる場合があります。しかし、これは型安全性と堅牢性を高めるための意図的なトレードオフであり、長期的な保守性や信頼性向上に寄与します。
エコシステムの成熟度: Effectは比較的新しいライブラリですが、fp-tsの作者がEffectチームに加わったことで、TypeScriptにおける関数型プログラミングの未来を担うとされています。コミュニティの成長とライブラリの安定化が期待されます。
「関数色付け問題」: Effectを返す関数は、その呼び出し元もEffectチェーン内にある必要があります。これはasync/awaitにおける問題と同様に、コードベース全体にEffectが伝播していく傾向があります。

まとめ

この記事では、TypeScriptにおけるエラーハンドリングの課題を克服し、型安全で堅牢なアプリケーションを構築するための強力なツール、Effect（旧Effect-TS）について解説しました。

重要なポイントは以下の通りです。

従来のtry...catchやunknown型エラーは、型安全性を損ない、エラーの伝播を不明瞭にする。
EffectのEffect<R, E, A>型は、エラー型Eを型システムに組み込み、コンパイル時にエラーを把握可能にする。
Data.TaggedErrorでカスタムエラーを定義し、Effect.genとEffect.failで型安全にエラーを生成する。
Effect.catchTagとEffect.catchAllを使い分けることで、特定の、またはすべてのエラーを型安全にハンドリングし、回復できる。
既存のPromiseベースのコードとの連携にはEffect.tryPromiseが有効。

Effectの導入には学習コストが伴いますが、その恩恵は型安全性の向上、デバッグの容易さ、そして長期的なコードの保守性に大きく貢献します。ぜひ、あなたのTypeScriptプロジェクトにEffectを段階的に導入し、その真価を体験してみてください。

より深く学ぶためには、Effectの公式ドキュメントを参照することをお勧めします。