@k2works/claude-code-booster 4.7.0 → 4.8.0

package/lib/assets/docs/article/grokkingfp/all/part-4-ch08-io-monad.md

@@ -1,972 +1,972 @@
-# Part IV - 第 8 章：IO モナドと副作用の分離
-
-## 8.1 はじめに：副作用の問題
-
-純粋関数は同じ入力に対して常に同じ出力を返し、外部の状態を変更しません。しかし、実際のプログラムには副作用が不可欠です：
-
-- ファイルの読み書き
-- ネットワーク通信
-- データベースアクセス
-- 乱数生成
-- 現在時刻の取得
-
-関数型プログラミングの核心的な問いは「副作用をどう管理するか」です。本章では、11 言語がこの問いにどう答えるかを横断的に比較し、以下を明らかにします：
-
-- IO の抽象化レベルの違い（言語組み込み vs ライブラリ vs 慣習的分離）
-- 「記述」と「実行」を分離する共通パターン
-- IO の合成方法と糖衣構文の言語間差異
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "副作用の管理" {
-  card "不純な関数" as impure #LightCoral
-  card "IO 型（記述）" as io #LightGreen
-  card "実行（interpret）" as run #LightBlue
-
-  impure --> io : 副作用をラップ
-  io --> run : 明示的に実行
-}
-
-note bottom of io
-  IO 値を作成しただけでは
-  副作用は発生しない
-end note
-
-@enduml
-```
-
----
-
-## 8.2 共通の本質：記述と実行の分離
-
-11 言語すべてに共通する IO の原則は、**副作用の「記述」と「実行」を分離する**ことです：
-
-1. **記述（Description）**: 副作用を持つ計算を「値」として表現する
-2. **合成（Composition）**: IO 値を flatMap / bind / chain で組み合わせる
-3. **実行（Interpretation）**: プログラムの端（main / エントリーポイント）で一度だけ実行する
-
-3 つの言語グループから代表例を見てみましょう：
-
-```haskell
--- Haskell: IO モナド（言語組み込み）
-castTheDie :: IO Int
-castTheDie = randomRIO (1, 6)
-
--- do 記法で合成
-castTheDieTwice :: IO Int
-castTheDieTwice = do
-    first  <- castTheDie
-    second <- castTheDie
-    return (first + second)
-```
-
-```scala
-// Scala: cats-effect IO（ライブラリ）
-def castTheDie(): IO[Int] = IO.delay(random.nextInt(6) + 1)
-
-// for 内包表記で合成
-def castTheDieTwice(): IO[Int] =
-  for {
-    first  <- castTheDie()
-    second <- castTheDie()
-  } yield first + second
-
-// 明示的に実行（unsafeRunSync）
-castTheDieTwice().unsafeRunSync()
-```
-
-```python
-# Python: カスタム LazyIO クラス
-def cast_the_die() -> LazyIO[int]:
-    return LazyIO(lambda: random.randint(1, 6))
-
-# bind/map で合成
-def cast_the_die_twice() -> LazyIO[int]:
-    return cast_the_die().bind(
-        lambda first: cast_the_die().map(lambda second: first + second)
-    )
-
-# 明示的に実行
-cast_the_die_twice().run()
-```
-
----
-
-## 8.3 IO の実装方式
-
-### アプローチ 1: 言語組み込み IO
-
-| 言語 | IO 型 | 実行方法 | 特徴 |
-|------|-------|---------|------|
-| **Haskell** | `IO a` | `main` 関数 | 言語レベルで純粋性を強制 |
-
-Haskell は唯一、IO を**言語レベル**で強制する言語です。`IO` 型を持たない関数は副作用を起こせません。
-
-### アプローチ 2: エフェクトライブラリ
-
-| 言語 | ライブラリ | IO 型 | 実行方法 |
-|------|-----------|-------|---------|
-| **Scala** | cats-effect | `IO[A]` | `unsafeRunSync()` |
-| **TypeScript** | fp-ts | `IO<A>` / `Task<A>` | `io()` / `task()` |
-| **Java** | 独自実装 | `IO<A>` | `unsafeRun()` |
-| **Python** | 独自実装 | `LazyIO[A]` | `run()` |
-| **Ruby** | 独自実装 | `IO` | `run!` |
-
-### アプローチ 3: 言語固有の非同期プリミティブ
-
-| 言語 | プリミティブ | 実行方法 | 特徴 |
-|------|-----------|---------|------|
-| **F#** | `Async<'a>` | `Async.RunSynchronously` | コンピュテーション式 |
-| **C#** | `Task<T>` | `await` / `GetResult()` | async/await |
-| **Rust** | `Future<Output=T>` | `.await` + tokio ランタイム | ゼロコスト抽象化 |
-
-### アプローチ 4: 実用的プリミティブ
-
-| 言語 | プリミティブ | 特徴 |
-|------|-----------|------|
-| **Clojure** | `delay` / `atom` / `future` | 複数のプリミティブを使い分け |
-| **Elixir** | 無名関数 + `Agent` / `Task` | OTP の軽量プロセスと組み合わせ |
-
----
-
-## 8.4 サイコロを振る：IO の基本パターン
-
-最もシンプルな IO の例として、サイコロを振る関数を 11 言語で比較します。
-
-### 代表 3 言語の比較
-
-**Haskell**: `randomRIO` が直接 `IO Int` を返す
-
-```haskell
-import System.Random (randomRIO)
-
-castTheDie :: IO Int
-castTheDie = randomRIO (1, 6)
-
-castTheDieTwice :: IO Int
-castTheDieTwice = do
-    first  <- castTheDie
-    second <- castTheDie
-    return (first + second)
-```
-
-**Scala**: `IO.delay` で不純な関数をラップ
-
-```scala
-import cats.effect.IO
-
-def castTheDie(): IO[Int] = IO.delay(random.nextInt(6) + 1)
-
-def castTheDieTwice(): IO[Int] =
-  for {
-    first  <- castTheDie()
-    second <- castTheDie()
-  } yield first + second
-```
-
-**Rust**: `async fn` が `Future` を返す
-
-```rust
-pub async fn cast_the_die() -> i32 {
-    cast_the_die_impure()
-}
-
-pub async fn cast_the_die_twice() -> i32 {
-    let first = cast_the_die().await;
-    let second = cast_the_die().await;
-    first + second
-}
-```
-
-### 全 11 言語の実装
-
-#### 関数型ファースト言語
-
-<details>
-<summary>Haskell 実装</summary>
-
-```haskell
-import System.Random (randomRIO)
-
-castTheDie :: IO Int
-castTheDie = randomRIO (1, 6)
-
-castTheDieTwice :: IO Int
-castTheDieTwice = do
-    first  <- castTheDie
-    second <- castTheDie
-    return (first + second)
-
--- replicateM で n 回繰り返し
-castTheDieN :: Int -> IO [Int]
-castTheDieN n = replicateM n castTheDie
-```
-
-Haskell では `randomRIO` 自体が `IO Int` を返します。副作用のある関数は必ず `IO` 型を持ち、純粋関数との分離が**言語レベルで強制**されます。
-
-</details>
-
-<details>
-<summary>Clojure 実装</summary>
-
-```clojure
-(defn cast-the-die-impure!
-  "サイコロを振る（不純）"
-  []
-  (inc (rand-int 6)))
-
-;; delay で遅延評価
-(defn cast-the-die []
-  (delay (cast-the-die-impure!)))
-
-;; force で実行
-(force (cast-the-die)) ; => 4
-
-;; atom で状態管理
-(def game-state (atom {:rolls [] :total 0}))
-
-(defn roll-die! []
-  (let [roll (cast-the-die-impure!)]
-    (swap! game-state
-           (fn [state]
-             (-> state
-                 (update :rolls conj roll)
-                 (update :total + roll))))
-    roll))
-```
-
-Clojure は IO モナドを使わず、`delay` / `atom` / `future` という実用的なプリミティブで副作用を管理します。`delay` は一度だけ評価されキャッシュされる点に注意してください。
-
-</details>
-
-<details>
-<summary>Elixir 実装</summary>
-
-```elixir
-def cast_the_die_impure do
-  :rand.uniform(6)
-end
-
-# 無名関数で遅延実行
-@spec delay((-> any())) :: (-> any())
-def delay(f) when is_function(f, 0), do: f
-
-@spec run((-> any())) :: any()
-def run(f) when is_function(f, 0), do: f.()
-
-def cast_the_die do
-  delay(fn -> cast_the_die_impure() end)
-end
-
-# flat_map で合成
-def cast_the_die_twice do
-  flat_map(cast_the_die(), fn first ->
-    map(cast_the_die(), fn second ->
-      first + second
-    end)
-  end)
-end
-```
-
-Elixir は無名関数 `fn -> ... end` で副作用を遅延実行します。Scala の `IO.delay` に相当する `delay/1` と `run/1` を自前で定義します。
-
-</details>
-
-<details>
-<summary>F# 実装</summary>
-
-```fsharp
-let castTheDie () : Async<int> =
-    async { return (Random()).Next(1, 7) }
-
-let castTheDieTwice () : Async<int> =
-    async {
-        let! firstCast = castTheDie ()
-        let! secondCast = castTheDie ()
-        return firstCast + secondCast
-    }
-
-// 実行
-let result = Async.RunSynchronously (castTheDieTwice ())
-```
-
-F# の `async { }` コンピュテーション式は Haskell の do 記法に相当します。`let!` でバインドし、`return` で値をラップします。
-
-</details>
-
-#### マルチパラダイム言語
-
-<details>
-<summary>Scala 実装</summary>
-
-```scala
-import cats.effect.IO
-
-def castTheDie(): IO[Int] = IO.delay(random.nextInt(6) + 1)
-
-def castTheDieTwice(): IO[Int] =
-  for {
-    first  <- castTheDie()
-    second <- castTheDie()
-  } yield first + second
-
-// IO.pure: 副作用なし
-val pureValue: IO[Int] = IO.pure(42)
-
-// 実行
-castTheDieTwice().unsafeRunSync()
-```
-
-</details>
-
-<details>
-<summary>Rust 実装</summary>
-
-```rust
-pub async fn cast_the_die() -> i32 {
-    use std::time::{SystemTime, UNIX_EPOCH};
-    let nanos = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap()
-        .subsec_nanos();
-    (nanos % 6) as i32 + 1
-}
-
-pub async fn cast_the_die_twice() -> i32 {
-    let first = cast_the_die().await;
-    let second = cast_the_die().await;
-    first + second
-}
-```
-
-Rust の `async fn` は `Future` を返します。`.await` されるまで実行されない点が IO モナドと共通しています。
-
-</details>
-
-<details>
-<summary>TypeScript (fp-ts) 実装</summary>
-
-```typescript
-import * as IO from 'fp-ts/IO'
-import { pipe } from 'fp-ts/function'
-
-const castTheDie: IO.IO<number> = () => Math.floor(Math.random() * 6) + 1
-
-const castTheDieTwice: IO.IO<number> = pipe(
-  castTheDie,
-  IO.chain((first) =>
-    pipe(
-      castTheDie,
-      IO.map((second) => first + second)
-    )
-  )
-)
-
-// 実行
-castTheDieTwice() // 2〜12 の値
-```
-
-fp-ts の `IO<A>` は `() => A` 型のエイリアスです。`chain`（= flatMap）と `map` で合成し、`()` で実行します。
-
-</details>
-
-#### OOP + FP ライブラリ言語
-
-<details>
-<summary>Java 実装</summary>
-
-```java
-public final class IO<A> {
-    private final Supplier<A> thunk;
-
-    private IO(Supplier<A> thunk) { this.thunk = thunk; }
-
-    public static <A> IO<A> delay(Supplier<A> supplier) {
-        return new IO<>(supplier);
-    }
-
-    public static <A> IO<A> pure(A value) {
-        return new IO<>(() -> value);
-    }
-
-    public A unsafeRun() { return thunk.get(); }
-
-    public <B> IO<B> map(Function<A, B> f) {
-        return new IO<>(() -> f.apply(thunk.get()));
-    }
-
-    public <B> IO<B> flatMap(Function<A, IO<B>> f) {
-        return new IO<>(() -> f.apply(thunk.get()).unsafeRun());
-    }
-}
-
-// 使用例
-public static IO<Integer> castTheDie() {
-    return IO.delay(() -> random.nextInt(6) + 1);
-}
-
-public static IO<Integer> castTheDieTwice() {
-    return castTheDie()
-        .flatMap(first -> castTheDie()
-            .map(second -> first + second));
-}
-```
-
-Java には IO ライブラリがないため、`Supplier<A>` ベースの IO クラスを自前で実装します。
-
-</details>
-
-<details>
-<summary>C# 実装</summary>
-
-```csharp
-public static Task<int> CastTheDie() =>
-    Task.Run(() => new Random().Next(1, 7));
-
-public static async Task<int> CastTheDieTwice()
-{
-    var first = await CastTheDie();
-    var second = await CastTheDie();
-    return first + second;
-}
-
-// 実行
-await CastTheDieTwice();
-```
-
-C# は `Task<T>` と `async/await` で副作用を管理します。Rust と同様に言語組み込みの非同期プリミティブを使います。
-
-</details>
-
-<details>
-<summary>Python 実装</summary>
-
-```python
-class LazyIO(Generic[T]):
-    def __init__(self, effect: Callable[[], T]) -> None:
-        self._effect = effect
-
-    def run(self) -> T:
-        return self._effect()
-
-    def map(self, f: Callable[[T], U]) -> "LazyIO[U]":
-        return LazyIO(lambda: f(self.run()))
-
-    def bind(self, f: Callable[[T], "LazyIO[U]"]) -> "LazyIO[U]":
-        return LazyIO(lambda: f(self.run()).run())
-
-# 使用例
-def cast_the_die() -> LazyIO[int]:
-    return LazyIO(lambda: random.randint(1, 6))
-
-def cast_the_die_twice() -> LazyIO[int]:
-    return cast_the_die().bind(
-        lambda first: cast_the_die().map(lambda second: first + second)
-    )
-```
-
-Python では Java と同様にカスタムの `LazyIO` クラスを実装します。ラムダ式で副作用を遅延評価し、`run()` で実行します。
-
-</details>
-
-<details>
-<summary>Ruby 実装</summary>
-
-```ruby
-class IO
-  def initialize(&computation)
-    @computation = computation
-  end
-
-  def self.delay(&block) = new(&block)
-  def self.pure(value) = new { value }
-
-  def run! = @computation.call
-
-  def fmap(&f) = IO.new { f.call(run!) }
-  def bind(&f) = IO.new { f.call(run!).run! }
-end
-
-# 使用例
-def cast_the_die
-  IO.delay { rand(1..6) }
-end
-
-def cast_the_die_twice
-  cast_the_die.bind do |first|
-    cast_the_die.fmap { |second| first + second }
-  end
-end
-```
-
-Ruby もカスタム IO クラスで実装します。ブロック構文によりネストが比較的読みやすくなっています。
-
-</details>
-
----
-
-## 8.5 IO の合成構文比較
-
-IO の合成は flatMap / bind の連鎖です。各言語の糖衣構文を比較します。
-
-### 合成構文一覧
-
-| 言語 | 構文 | バインド | 例 |
-|------|------|---------|-----|
-| **Haskell** | do 記法 | `<-` | `do { x <- io; return x }` |
-| **Scala** | for 内包表記 | `<-` | `for { x <- io } yield x` |
-| **F#** | async { } | `let!` | `async { let! x = io; return x }` |
-| **C#** | async/await | `await` | `async { var x = await io; return x; }` |
-| **Rust** | async/await | `.await` | `async { let x = io.await; x }` |
-| **TypeScript** | pipe + chain | `chain` | `pipe(io, IO.chain(x => ...))` |
-| **Elixir** | flat_map | `flat_map` | `flat_map(io, fn x -> ... end)` |
-| **Java** | flatMap chain | `.flatMap` | `io.flatMap(x -> ...)` |
-| **Python** | bind chain | `.bind` | `io.bind(lambda x: ...)` |
-| **Ruby** | bind block | `.bind` | `io.bind { \|x\| ... }` |
-| **Clojure** | delay + force | 手動 | `(force (delay ...))` |
-
-### 可読性の比較
-
-**糖衣構文あり**（手続き的に読める）:
-
-```haskell
--- Haskell: do 記法
-scheduledMeetings person1 person2 = do
-    entries1 <- calendarEntries person1
-    entries2 <- calendarEntries person2
-    return (entries1 ++ entries2)
-```
-
-```fsharp
-// F#: async { } コンピュテーション式
-let scheduledMeetings person1 person2 =
-    async {
-        let! entries1 = calendarEntries person1
-        let! entries2 = calendarEntries person2
-        return entries1 @ entries2
-    }
-```
-
-```csharp
-// C#: async/await
-public static async Task<Seq<MeetingTime>> ScheduledMeetings(
-    string person1, string person2)
-{
-    var entries1 = await CalendarEntries(person1);
-    var entries2 = await CalendarEntries(person2);
-    return entries1.Concat(entries2);
-}
-```
-
-**糖衣構文なし**（ラムダのネストが必要）:
-
-```java
-// Java: flatMap チェーン
-public static IO<List<MeetingTime>> scheduledMeetings(
-    String person1, String person2) {
-    return calendarEntries(person1).flatMap(entries1 ->
-        calendarEntries(person2).map(entries2 ->
-            entries1.appendedAll(entries2)));
-}
-```
-
----
-
-## 8.6 エラーハンドリングとリトライ
-
-IO は失敗する可能性があります。各言語のエラーハンドリングとリトライ戦略を比較します。
-
-### orElse によるフォールバック
-
-```scala
-// Scala: orElse
-val year: IO[Int]   = IO.delay(996)
-val noYear: IO[Int] = IO.delay(throw new Exception("no year"))
-
-year.orElse(IO.delay(2020)).unsafeRunSync()    // 996
-noYear.orElse(IO.delay(2020)).unsafeRunSync()  // 2020
-```
-
-### リトライ戦略の比較
-
-#### 代表 3 言語
-
-**Scala**: orElse の fold
-
-```scala
-def retry[A](action: IO[A], maxRetries: Int): IO[A] =
-  List.range(0, maxRetries)
-    .map(_ => action)
-    .foldLeft(action)((program, retryAction) =>
-      program.orElse(retryAction))
-```
-
-**Haskell**: 再帰 + try/catch
-
-```haskell
-retryIO :: Int -> IO a -> IO (Maybe a)
-retryIO 0 _      = return Nothing
-retryIO n action = do
-    result <- try action :: IO (Either SomeException a)
-    case result of
-        Right a -> return (Just a)
-        Left _  -> retryIO (n - 1) action
-```
-
-**Rust**: ジェネリック関数 + Result
-
-```rust
-pub async fn retry<T, E, F, Fut>(action: F, max_retries: usize) -> Result<T, E>
-where
-    F: Fn() -> Fut,
-    Fut: Future<Output = Result<T, E>>,
-{
-    let mut last_error = None;
-    for _ in 0..max_retries {
-        match action().await {
-            Ok(result) => return Ok(result),
-            Err(e) => last_error = Some(e),
-        }
-    }
-    Err(last_error.unwrap())
-}
-```
-
-### 全 11 言語のエラーハンドリング比較
-
-| 言語 | フォールバック | リトライ方式 | エラー型 |
-|------|-------------|------------|---------|
-| **Haskell** | `catch` / 手動 | 再帰 + `try` | `SomeException` |
-| **Scala** | `IO.orElse` | fold / handleErrorWith | `Throwable` |
-| **Rust** | `or_else` / `unwrap_or` | ループ + `Result` | `E` (ジェネリック) |
-| **F#** | `try/with` + Async | Async.Catch | `exn` |
-| **C#** | `try/catch` + Task | ループ + try/catch | `Exception` |
-| **TypeScript** | `TaskEither` + `orElse` | pipe + orElse | `E` (ジェネリック) |
-| **Java** | try/catch 内 IO | ループ + try/catch | `Exception` |
-| **Python** | try/except 内 LazyIO | ループ + try/except | `Exception` |
-| **Ruby** | `or_else` ブロック | ループ + rescue | `StandardError` |
-| **Clojure** | `try/catch` | 再帰 + try/catch | Java 例外 |
-| **Elixir** | `or_else` 関数 | 再帰 + rescue | `RuntimeError` |
-
----
-
-## 8.7 sequence：IO のリスト変換
-
-`List[IO[A]]` → `IO[List[A]]` の変換は、複数の IO を一つにまとめる重要なパターンです。
-
-### 代表的な実装
-
-```scala
-// Scala: cats の sequence
-import cats.implicits._
-
-val actions: List[IO[Int]] = List(IO.pure(1), IO.pure(2), IO.pure(3))
-val combined: IO[List[Int]] = actions.sequence
-combined.unsafeRunSync()  // List(1, 2, 3)
-
-// 複数人の予定を取得
-def scheduledMeetings(attendees: List[String]): IO[List[MeetingTime]] =
-  attendees
-    .map(attendee => retry(calendarEntries(attendee), 10))
-    .sequence
-    .map(_.flatten)
-```
-
-```haskell
--- Haskell: sequence（標準ライブラリ）
-sequenceIO :: [IO a] -> IO [a]
-sequenceIO []     = return []
-sequenceIO (x:xs) = do
-    a  <- x
-    as <- sequenceIO xs
-    return (a : as)
-
--- replicateM で n 回実行
-castTheDieN :: Int -> IO [Int]
-castTheDieN n = replicateM n castTheDie
-```
-
-```rust
-// Rust: join_all で並行実行
-pub async fn scheduled_meetings_for_all(attendees: &[&str]) -> Vec<MeetingTime> {
-    let futures: Vec<_> = attendees
-        .iter()
-        .map(|name| calendar_entries(name))
-        .collect();
-
-    let results = futures::future::join_all(futures).await;
-    results.into_iter().flatten().collect()
-}
-```
-
-### 語彙比較
-
-| 言語 | List[IO[A]] → IO[List[A]] | 並行実行 |
-|------|--------------------------|---------|
-| **Haskell** | `sequence` / `mapM` | `mapConcurrently` |
-| **Scala** | `.sequence` (cats) | `parSequence` |
-| **Rust** | `join_all` / `try_join_all` | `join_all`（デフォルト並行） |
-| **F#** | `Async.Parallel` | `Async.Parallel`（デフォルト並行） |
-| **C#** | `Task.WhenAll` | `Task.WhenAll`（デフォルト並行） |
-| **TypeScript** | `array.sequence(T.task)` | `Promise.all` |
-| **Java** | 手動 flatMap ループ | `CompletableFuture.allOf` |
-| **Python** | 手動 bind ループ | `asyncio.gather` |
-| **Ruby** | 手動 bind ループ | `Thread` / `Ractor` |
-| **Clojure** | `(doall (map deref ...))` | `pmap` |
-| **Elixir** | 手動 fold | `Task.async_stream` |
-
----
-
-## 8.8 比較分析：3 つの発見
-
-### 発見 1: IO の抽象化レベルは 4 段階に分かれる
-
-```plantuml
-@startuml
-!theme plain
-left to right direction
-
-rectangle "Level 1: 言語組み込み IO" #LightGreen {
-  card "Haskell (IO モナド)" as h
-}
-
-rectangle "Level 2: エフェクトライブラリ" #LightBlue {
-  card "Scala (cats-effect IO)" as sc
-  card "TypeScript (fp-ts IO/Task)" as ts
-}
-
-rectangle "Level 3: 言語の非同期プリミティブ" #LightYellow {
-  card "F# (Async)" as fs
-  card "C# (Task)" as cs
-  card "Rust (Future / async)" as rs
-}
-
-rectangle "Level 4: 慣習的分離 / 自前実装" #LightCoral {
-  card "Java (カスタム IO)" as jv
-  card "Python (LazyIO)" as py
-  card "Ruby (カスタム IO)" as rb
-  card "Clojure (delay/atom)" as clj
-  card "Elixir (無名関数)" as ex
-}
-
-@enduml
-```
-
-**Level 1（Haskell）** は言語レベルで純粋性を保証します。IO 型を持たない関数は副作用を起こせないため、型シグネチャだけで純粋性がわかります。
-
-**Level 2（Scala, TypeScript）** はライブラリが IO 型を提供し、`unsafeRunSync` / `io()` で実行を明示します。純粋性はライブラリの規約に依存します。
-
-**Level 3（F#, C#, Rust）** は言語の非同期プリミティブ（`Async`, `Task`, `Future`）で副作用を遅延実行します。IO モナドとは異なりますが、「記述と実行の分離」を実現しています。
-
-**Level 4（Java, Python, Ruby, Clojure, Elixir）** は標準的な IO 型がなく、カスタム実装または慣習的な分離に頼ります。
-
-### 発見 2: 合成構文は 3 系統に分かれる
-
-| 系統 | 構文 | 言語 | 可読性 |
-|------|------|------|--------|
-| **モナド内包表記** | do / for / async { } / LINQ | Haskell, Scala, F#, C# | 高（手続き的に読める） |
-| **async/await** | async fn / await | C#, Rust, F# | 高（主流の構文） |
-| **明示的チェーン** | flatMap / bind / chain | Java, Python, Ruby, TypeScript, Elixir, Clojure | 低〜中（ラムダのネスト） |
-
-モナド内包表記と async/await は本質的に同じ脱糖を行います：
-
-```
--- Haskell do 記法の脱糖
-do { x <- io1; y <- io2; return (x + y) }
-  ≡ io1 >>= \x -> io2 >>= \y -> return (x + y)
-
--- C# async/await の脱糖
-async { var x = await task1; var y = await task2; return x + y; }
-  ≡ task1.ContinueWith(x => task2.ContinueWith(y => x + y))
-```
-
-### 発見 3: 純粋コア / 不純シェルはすべての言語で有効
-
-IO の抽象化レベルに関わらず、**Pure Core / Impure Shell** パターンはすべての言語で適用できます：
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "Pure Core / Impure Shell" {
-  rectangle "Impure Shell（IO 境界）" #LightCoral {
-    rectangle "Pure Core（純粋ロジック）" #LightGreen {
-      card "meetingsOverlap" as overlap
-      card "possibleMeetings" as possible
-      card "parseAndValidate" as parse
-    }
-
-    card "calendarEntries" as cal
-    card "createMeeting" as create
-    card "getLine / putStrLn" as stdio
-  }
-
-  cal --> possible : データを渡す
-  possible --> create : 結果を渡す
-  stdio --> parse : 入力を渡す
-}
-
-note bottom
-  ビジネスロジックは純粋関数で
-  IO は境界部分のみ
-end note
-
-@enduml
-```
-
-```haskell
--- Haskell: 純粋関数と IO の明確な分離
--- 純粋関数（テスト容易）
-possibleMeetings :: [MeetingTime] -> Int -> Int -> Int -> [MeetingTime]
-possibleMeetings existingMeetings startHour endHour lengthHours =
-    let slots = [MeetingTime s (s + lengthHours) | s <- [startHour .. endHour - lengthHours]]
-    in filter (\slot -> all (not . meetingsOverlap slot) existingMeetings) slots
-
--- IO 関数（外部 API）
-calendarEntries :: String -> IO [MeetingTime]
-scheduledMeetings :: String -> String -> IO [MeetingTime]
-```
-
----
-
-## 8.9 言語固有の特徴
-
-### Haskell: IO の純粋性保証
-
-Haskell は唯一、**型シグネチャで純粋性を保証**する言語です：
-
-```haskell
--- 純粋関数（IO なし）：副作用は不可能
-possibleMeetings :: [MeetingTime] -> Int -> Int -> Int -> [MeetingTime]
-
--- IO 関数：副作用があることが明示的
-calendarEntries :: String -> IO [MeetingTime]
-```
-
-コンパイラが純粋関数内の IO 使用を禁止するため、「うっかり副作用を混入」という事故が起きません。
-
-### Rust: ゼロコスト抽象化の async/await
-
-Rust の `async fn` はコンパイル時にステートマシンに変換され、ランタイムオーバーヘッドがゼロです：
-
-```rust
-// コンパイル後、ヒープ割り当てなしのステートマシンに変換
-pub async fn scheduled_meetings(person1: &str, person2: &str) -> Vec<MeetingTime> {
-    let entries1 = calendar_entries(person1).await;
-    let entries2 = calendar_entries(person2).await;
-    [entries1, entries2].concat()
-}
-```
-
-### TypeScript: IO / Task / TaskEither の 3 層
-
-fp-ts は同期・非同期・エラー付き非同期の 3 つの IO 型を提供します：
-
-```typescript
-import * as IO from 'fp-ts/IO'         // 同期 IO
-import * as T from 'fp-ts/Task'         // 非同期 IO（成功のみ）
-import * as TE from 'fp-ts/TaskEither'  // 非同期 IO（エラーあり）
-
-// IO<A>:     () => A
-// Task<A>:   () => Promise<A>
-// TaskEither<E, A>: () => Promise<Either<E, A>>
-```
-
-### Clojure: 複数プリミティブの使い分け
-
-Clojure は単一の IO 型ではなく、用途別のプリミティブを使い分けます：
-
-```clojure
-;; delay: 遅延評価（キャッシュあり）
-(def lazy-val (delay (expensive-computation)))
-
-;; atom: 状態管理（同期的な更新）
-(def state (atom {:count 0}))
-(swap! state update :count inc)
-
-;; future: 非同期計算（別スレッド）
-(def async-result (future (api-call)))
-@async-result  ; 結果を待つ
-```
-
-### Elixir: OTP プロセスとの統合
-
-Elixir は無名関数に加え、`Agent` と `Task` で状態管理と非同期処理を OTP の軽量プロセスで実現します：
-
-```elixir
-# Agent: 状態管理（プロセス内）
-{:ok, agent} = Agent.start_link(fn -> %{} end)
-Agent.update(agent, fn state -> Map.put(state, :key, "value") end)
-
-# Task: 非同期処理（並行プロセス）
-task = Task.async(fn -> expensive_computation() end)
-result = Task.await(task)
-```
-
----
-
-## 8.10 実践的な選択指針
-
-### IO の抽象化レベルの選択
-
-| 要件 | 推奨言語 | 理由 |
-|------|---------|------|
-| 最も厳格な純粋性保証 | Haskell | 型レベルで IO と純粋関数を分離 |
-| 高性能な非同期処理 | Rust | ゼロコスト抽象化の async/await |
-| JVM でのエフェクト管理 | Scala + cats-effect | 成熟した IO ライブラリ |
-| .NET での非同期処理 | F# (Async) / C# (Task) | コンピュテーション式 / async-await |
-| フロントエンドでの型安全 IO | TypeScript + fp-ts | IO / Task / TaskEither の 3 層 |
-| 分散システム | Elixir | OTP の軽量プロセスモデル |
-| 並行状態管理 | Clojure | atom / ref / STM |
-
-### プロジェクト規模別の推奨
-
-| 規模 | 推奨アプローチ | 言語例 |
-|------|-------------|-------|
-| 小規模 | Pure Core / Impure Shell の慣習的分離 | Python, Ruby, Java |
-| 中規模 | エフェクトライブラリの導入 | Scala (cats-effect), TypeScript (fp-ts) |
-| 大規模 | 言語レベルの IO 分離 | Haskell, F# |
-
----
-
-## 8.11 まとめ
-
-本章では、11 言語での IO モナドと副作用の分離を比較し、以下を確認しました：
-
-**共通の原則**:
-
-- IO = 副作用の「記述」と「実行」の分離
-- flatMap / bind / chain による IO の合成
-- Pure Core / Impure Shell パターンはすべての言語で有効
-
-**言語間の差異**:
-
-- 抽象化レベルは 4 段階（言語組み込み → ライブラリ → 非同期プリミティブ → 慣習的分離）
-- 合成構文は 3 系統（モナド内包表記 / async-await / 明示的チェーン）
-- Haskell のみが型レベルで純粋性を保証
-
-**学び**:
-
-- 副作用の管理は「型で表現する」か「慣習で分離する」かの選択
-- async/await は IO モナドの脱糖と本質的に同じ
-- エラーハンドリングとリトライは IO の合成で自然に表現できる
-
----
-
-### 各言語の詳細記事
-
-| 言語 | 記事リンク |
-|------|-----------|
-| Scala | [Part IV: IO と副作用の管理](../scala/part-4.md) |
-| Java | [Part IV: IO と副作用の管理](../java/part-4.md) |
-| F# | [Part IV: 非同期処理とストリーム](../fsharp/part-4.md) |
-| C# | [Part IV: 非同期処理とストリーム](../csharp/part-4.md) |
-| Haskell | [Part IV: IO と副作用の管理](../haskell/part-4.md) |
-| Clojure | [Part IV: 状態管理とストリーム処理](../clojure/part-4.md) |
-| Elixir | [Part IV: IO とストリーム処理](../elixir/part-4.md) |
-| Rust | [Part IV: 非同期処理とストリーム](../rust/part-4.md) |
-| Python | [Part IV: IO と副作用の管理](../python/part-4.md) |
-| TypeScript | [Part IV: IO と副作用の管理](../typescript/part-4.md) |
-| Ruby | [Part IV: IO と副作用の管理](../ruby/part-4.md) |
+# Part IV - 第 8 章：IO モナドと副作用の分離
+
+## 8.1 はじめに：副作用の問題
+
+純粋関数は同じ入力に対して常に同じ出力を返し、外部の状態を変更しません。しかし、実際のプログラムには副作用が不可欠です：
+
+- ファイルの読み書き
+- ネットワーク通信
+- データベースアクセス
+- 乱数生成
+- 現在時刻の取得
+
+関数型プログラミングの核心的な問いは「副作用をどう管理するか」です。本章では、11 言語がこの問いにどう答えるかを横断的に比較し、以下を明らかにします：
+
+- IO の抽象化レベルの違い（言語組み込み vs ライブラリ vs 慣習的分離）
+- 「記述」と「実行」を分離する共通パターン
+- IO の合成方法と糖衣構文の言語間差異
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "副作用の管理" {
+  card "不純な関数" as impure #LightCoral
+  card "IO 型（記述）" as io #LightGreen
+  card "実行（interpret）" as run #LightBlue
+
+  impure --> io : 副作用をラップ
+  io --> run : 明示的に実行
+}
+
+note bottom of io
+  IO 値を作成しただけでは
+  副作用は発生しない
+end note
+
+@enduml
+```
+
+---
+
+## 8.2 共通の本質：記述と実行の分離
+
+11 言語すべてに共通する IO の原則は、**副作用の「記述」と「実行」を分離する**ことです：
+
+1. **記述（Description）**: 副作用を持つ計算を「値」として表現する
+2. **合成（Composition）**: IO 値を flatMap / bind / chain で組み合わせる
+3. **実行（Interpretation）**: プログラムの端（main / エントリーポイント）で一度だけ実行する
+
+3 つの言語グループから代表例を見てみましょう：
+
+```haskell
+-- Haskell: IO モナド（言語組み込み）
+castTheDie :: IO Int
+castTheDie = randomRIO (1, 6)
+
+-- do 記法で合成
+castTheDieTwice :: IO Int
+castTheDieTwice = do
+    first  <- castTheDie
+    second <- castTheDie
+    return (first + second)
+```
+
+```scala
+// Scala: cats-effect IO（ライブラリ）
+def castTheDie(): IO[Int] = IO.delay(random.nextInt(6) + 1)
+
+// for 内包表記で合成
+def castTheDieTwice(): IO[Int] =
+  for {
+    first  <- castTheDie()
+    second <- castTheDie()
+  } yield first + second
+
+// 明示的に実行（unsafeRunSync）
+castTheDieTwice().unsafeRunSync()
+```
+
+```python
+# Python: カスタム LazyIO クラス
+def cast_the_die() -> LazyIO[int]:
+    return LazyIO(lambda: random.randint(1, 6))
+
+# bind/map で合成
+def cast_the_die_twice() -> LazyIO[int]:
+    return cast_the_die().bind(
+        lambda first: cast_the_die().map(lambda second: first + second)
+    )
+
+# 明示的に実行
+cast_the_die_twice().run()
+```
+
+---
+
+## 8.3 IO の実装方式
+
+### アプローチ 1: 言語組み込み IO
+
+| 言語 | IO 型 | 実行方法 | 特徴 |
+|------|-------|---------|------|
+| **Haskell** | `IO a` | `main` 関数 | 言語レベルで純粋性を強制 |
+
+Haskell は唯一、IO を**言語レベル**で強制する言語です。`IO` 型を持たない関数は副作用を起こせません。
+
+### アプローチ 2: エフェクトライブラリ
+
+| 言語 | ライブラリ | IO 型 | 実行方法 |
+|------|-----------|-------|---------|
+| **Scala** | cats-effect | `IO[A]` | `unsafeRunSync()` |
+| **TypeScript** | fp-ts | `IO<A>` / `Task<A>` | `io()` / `task()` |
+| **Java** | 独自実装 | `IO<A>` | `unsafeRun()` |
+| **Python** | 独自実装 | `LazyIO[A]` | `run()` |
+| **Ruby** | 独自実装 | `IO` | `run!` |
+
+### アプローチ 3: 言語固有の非同期プリミティブ
+
+| 言語 | プリミティブ | 実行方法 | 特徴 |
+|------|-----------|---------|------|
+| **F#** | `Async<'a>` | `Async.RunSynchronously` | コンピュテーション式 |
+| **C#** | `Task<T>` | `await` / `GetResult()` | async/await |
+| **Rust** | `Future<Output=T>` | `.await` + tokio ランタイム | ゼロコスト抽象化 |
+
+### アプローチ 4: 実用的プリミティブ
+
+| 言語 | プリミティブ | 特徴 |
+|------|-----------|------|
+| **Clojure** | `delay` / `atom` / `future` | 複数のプリミティブを使い分け |
+| **Elixir** | 無名関数 + `Agent` / `Task` | OTP の軽量プロセスと組み合わせ |
+
+---
+
+## 8.4 サイコロを振る：IO の基本パターン
+
+最もシンプルな IO の例として、サイコロを振る関数を 11 言語で比較します。
+
+### 代表 3 言語の比較
+
+**Haskell**: `randomRIO` が直接 `IO Int` を返す
+
+```haskell
+import System.Random (randomRIO)
+
+castTheDie :: IO Int
+castTheDie = randomRIO (1, 6)
+
+castTheDieTwice :: IO Int
+castTheDieTwice = do
+    first  <- castTheDie
+    second <- castTheDie
+    return (first + second)
+```
+
+**Scala**: `IO.delay` で不純な関数をラップ
+
+```scala
+import cats.effect.IO
+
+def castTheDie(): IO[Int] = IO.delay(random.nextInt(6) + 1)
+
+def castTheDieTwice(): IO[Int] =
+  for {
+    first  <- castTheDie()
+    second <- castTheDie()
+  } yield first + second
+```
+
+**Rust**: `async fn` が `Future` を返す
+
+```rust
+pub async fn cast_the_die() -> i32 {
+    cast_the_die_impure()
+}
+
+pub async fn cast_the_die_twice() -> i32 {
+    let first = cast_the_die().await;
+    let second = cast_the_die().await;
+    first + second
+}
+```
+
+### 全 11 言語の実装
+
+#### 関数型ファースト言語
+
+<details>
+<summary>Haskell 実装</summary>
+
+```haskell
+import System.Random (randomRIO)
+
+castTheDie :: IO Int
+castTheDie = randomRIO (1, 6)
+
+castTheDieTwice :: IO Int
+castTheDieTwice = do
+    first  <- castTheDie
+    second <- castTheDie
+    return (first + second)
+
+-- replicateM で n 回繰り返し
+castTheDieN :: Int -> IO [Int]
+castTheDieN n = replicateM n castTheDie
+```
+
+Haskell では `randomRIO` 自体が `IO Int` を返します。副作用のある関数は必ず `IO` 型を持ち、純粋関数との分離が**言語レベルで強制**されます。
+
+</details>
+
+<details>
+<summary>Clojure 実装</summary>
+
+```clojure
+(defn cast-the-die-impure!
+  "サイコロを振る（不純）"
+  []
+  (inc (rand-int 6)))
+
+;; delay で遅延評価
+(defn cast-the-die []
+  (delay (cast-the-die-impure!)))
+
+;; force で実行
+(force (cast-the-die)) ; => 4
+
+;; atom で状態管理
+(def game-state (atom {:rolls [] :total 0}))
+
+(defn roll-die! []
+  (let [roll (cast-the-die-impure!)]
+    (swap! game-state
+           (fn [state]
+             (-> state
+                 (update :rolls conj roll)
+                 (update :total + roll))))
+    roll))
+```
+
+Clojure は IO モナドを使わず、`delay` / `atom` / `future` という実用的なプリミティブで副作用を管理します。`delay` は一度だけ評価されキャッシュされる点に注意してください。
+
+</details>
+
+<details>
+<summary>Elixir 実装</summary>
+
+```elixir
+def cast_the_die_impure do
+  :rand.uniform(6)
+end
+
+# 無名関数で遅延実行
+@spec delay((-> any())) :: (-> any())
+def delay(f) when is_function(f, 0), do: f
+
+@spec run((-> any())) :: any()
+def run(f) when is_function(f, 0), do: f.()
+
+def cast_the_die do
+  delay(fn -> cast_the_die_impure() end)
+end
+
+# flat_map で合成
+def cast_the_die_twice do
+  flat_map(cast_the_die(), fn first ->
+    map(cast_the_die(), fn second ->
+      first + second
+    end)
+  end)
+end
+```
+
+Elixir は無名関数 `fn -> ... end` で副作用を遅延実行します。Scala の `IO.delay` に相当する `delay/1` と `run/1` を自前で定義します。
+
+</details>
+
+<details>
+<summary>F# 実装</summary>
+
+```fsharp
+let castTheDie () : Async<int> =
+    async { return (Random()).Next(1, 7) }
+
+let castTheDieTwice () : Async<int> =
+    async {
+        let! firstCast = castTheDie ()
+        let! secondCast = castTheDie ()
+        return firstCast + secondCast
+    }
+
+// 実行
+let result = Async.RunSynchronously (castTheDieTwice ())
+```
+
+F# の `async { }` コンピュテーション式は Haskell の do 記法に相当します。`let!` でバインドし、`return` で値をラップします。
+
+</details>
+
+#### マルチパラダイム言語
+
+<details>
+<summary>Scala 実装</summary>
+
+```scala
+import cats.effect.IO
+
+def castTheDie(): IO[Int] = IO.delay(random.nextInt(6) + 1)
+
+def castTheDieTwice(): IO[Int] =
+  for {
+    first  <- castTheDie()
+    second <- castTheDie()
+  } yield first + second
+
+// IO.pure: 副作用なし
+val pureValue: IO[Int] = IO.pure(42)
+
+// 実行
+castTheDieTwice().unsafeRunSync()
+```
+
+</details>
+
+<details>
+<summary>Rust 実装</summary>
+
+```rust
+pub async fn cast_the_die() -> i32 {
+    use std::time::{SystemTime, UNIX_EPOCH};
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .subsec_nanos();
+    (nanos % 6) as i32 + 1
+}
+
+pub async fn cast_the_die_twice() -> i32 {
+    let first = cast_the_die().await;
+    let second = cast_the_die().await;
+    first + second
+}
+```
+
+Rust の `async fn` は `Future` を返します。`.await` されるまで実行されない点が IO モナドと共通しています。
+
+</details>
+
+<details>
+<summary>TypeScript (fp-ts) 実装</summary>
+
+```typescript
+import * as IO from 'fp-ts/IO'
+import { pipe } from 'fp-ts/function'
+
+const castTheDie: IO.IO<number> = () => Math.floor(Math.random() * 6) + 1
+
+const castTheDieTwice: IO.IO<number> = pipe(
+  castTheDie,
+  IO.chain((first) =>
+    pipe(
+      castTheDie,
+      IO.map((second) => first + second)
+    )
+  )
+)
+
+// 実行
+castTheDieTwice() // 2〜12 の値
+```
+
+fp-ts の `IO<A>` は `() => A` 型のエイリアスです。`chain`（= flatMap）と `map` で合成し、`()` で実行します。
+
+</details>
+
+#### OOP + FP ライブラリ言語
+
+<details>
+<summary>Java 実装</summary>
+
+```java
+public final class IO<A> {
+    private final Supplier<A> thunk;
+
+    private IO(Supplier<A> thunk) { this.thunk = thunk; }
+
+    public static <A> IO<A> delay(Supplier<A> supplier) {
+        return new IO<>(supplier);
+    }
+
+    public static <A> IO<A> pure(A value) {
+        return new IO<>(() -> value);
+    }
+
+    public A unsafeRun() { return thunk.get(); }
+
+    public <B> IO<B> map(Function<A, B> f) {
+        return new IO<>(() -> f.apply(thunk.get()));
+    }
+
+    public <B> IO<B> flatMap(Function<A, IO<B>> f) {
+        return new IO<>(() -> f.apply(thunk.get()).unsafeRun());
+    }
+}
+
+// 使用例
+public static IO<Integer> castTheDie() {
+    return IO.delay(() -> random.nextInt(6) + 1);
+}
+
+public static IO<Integer> castTheDieTwice() {
+    return castTheDie()
+        .flatMap(first -> castTheDie()
+            .map(second -> first + second));
+}
+```
+
+Java には IO ライブラリがないため、`Supplier<A>` ベースの IO クラスを自前で実装します。
+
+</details>
+
+<details>
+<summary>C# 実装</summary>
+
+```csharp
+public static Task<int> CastTheDie() =>
+    Task.Run(() => new Random().Next(1, 7));
+
+public static async Task<int> CastTheDieTwice()
+{
+    var first = await CastTheDie();
+    var second = await CastTheDie();
+    return first + second;
+}
+
+// 実行
+await CastTheDieTwice();
+```
+
+C# は `Task<T>` と `async/await` で副作用を管理します。Rust と同様に言語組み込みの非同期プリミティブを使います。
+
+</details>
+
+<details>
+<summary>Python 実装</summary>
+
+```python
+class LazyIO(Generic[T]):
+    def __init__(self, effect: Callable[[], T]) -> None:
+        self._effect = effect
+
+    def run(self) -> T:
+        return self._effect()
+
+    def map(self, f: Callable[[T], U]) -> "LazyIO[U]":
+        return LazyIO(lambda: f(self.run()))
+
+    def bind(self, f: Callable[[T], "LazyIO[U]"]) -> "LazyIO[U]":
+        return LazyIO(lambda: f(self.run()).run())
+
+# 使用例
+def cast_the_die() -> LazyIO[int]:
+    return LazyIO(lambda: random.randint(1, 6))
+
+def cast_the_die_twice() -> LazyIO[int]:
+    return cast_the_die().bind(
+        lambda first: cast_the_die().map(lambda second: first + second)
+    )
+```
+
+Python では Java と同様にカスタムの `LazyIO` クラスを実装します。ラムダ式で副作用を遅延評価し、`run()` で実行します。
+
+</details>
+
+<details>
+<summary>Ruby 実装</summary>
+
+```ruby
+class IO
+  def initialize(&computation)
+    @computation = computation
+  end
+
+  def self.delay(&block) = new(&block)
+  def self.pure(value) = new { value }
+
+  def run! = @computation.call
+
+  def fmap(&f) = IO.new { f.call(run!) }
+  def bind(&f) = IO.new { f.call(run!).run! }
+end
+
+# 使用例
+def cast_the_die
+  IO.delay { rand(1..6) }
+end
+
+def cast_the_die_twice
+  cast_the_die.bind do |first|
+    cast_the_die.fmap { |second| first + second }
+  end
+end
+```
+
+Ruby もカスタム IO クラスで実装します。ブロック構文によりネストが比較的読みやすくなっています。
+
+</details>
+
+---
+
+## 8.5 IO の合成構文比較
+
+IO の合成は flatMap / bind の連鎖です。各言語の糖衣構文を比較します。
+
+### 合成構文一覧
+
+| 言語 | 構文 | バインド | 例 |
+|------|------|---------|-----|
+| **Haskell** | do 記法 | `<-` | `do { x <- io; return x }` |
+| **Scala** | for 内包表記 | `<-` | `for { x <- io } yield x` |
+| **F#** | async { } | `let!` | `async { let! x = io; return x }` |
+| **C#** | async/await | `await` | `async { var x = await io; return x; }` |
+| **Rust** | async/await | `.await` | `async { let x = io.await; x }` |
+| **TypeScript** | pipe + chain | `chain` | `pipe(io, IO.chain(x => ...))` |
+| **Elixir** | flat_map | `flat_map` | `flat_map(io, fn x -> ... end)` |
+| **Java** | flatMap chain | `.flatMap` | `io.flatMap(x -> ...)` |
+| **Python** | bind chain | `.bind` | `io.bind(lambda x: ...)` |
+| **Ruby** | bind block | `.bind` | `io.bind { \|x\| ... }` |
+| **Clojure** | delay + force | 手動 | `(force (delay ...))` |
+
+### 可読性の比較
+
+**糖衣構文あり**（手続き的に読める）:
+
+```haskell
+-- Haskell: do 記法
+scheduledMeetings person1 person2 = do
+    entries1 <- calendarEntries person1
+    entries2 <- calendarEntries person2
+    return (entries1 ++ entries2)
+```
+
+```fsharp
+// F#: async { } コンピュテーション式
+let scheduledMeetings person1 person2 =
+    async {
+        let! entries1 = calendarEntries person1
+        let! entries2 = calendarEntries person2
+        return entries1 @ entries2
+    }
+```
+
+```csharp
+// C#: async/await
+public static async Task<Seq<MeetingTime>> ScheduledMeetings(
+    string person1, string person2)
+{
+    var entries1 = await CalendarEntries(person1);
+    var entries2 = await CalendarEntries(person2);
+    return entries1.Concat(entries2);
+}
+```
+
+**糖衣構文なし**（ラムダのネストが必要）:
+
+```java
+// Java: flatMap チェーン
+public static IO<List<MeetingTime>> scheduledMeetings(
+    String person1, String person2) {
+    return calendarEntries(person1).flatMap(entries1 ->
+        calendarEntries(person2).map(entries2 ->
+            entries1.appendedAll(entries2)));
+}
+```
+
+---
+
+## 8.6 エラーハンドリングとリトライ
+
+IO は失敗する可能性があります。各言語のエラーハンドリングとリトライ戦略を比較します。
+
+### orElse によるフォールバック
+
+```scala
+// Scala: orElse
+val year: IO[Int]   = IO.delay(996)
+val noYear: IO[Int] = IO.delay(throw new Exception("no year"))
+
+year.orElse(IO.delay(2020)).unsafeRunSync()    // 996
+noYear.orElse(IO.delay(2020)).unsafeRunSync()  // 2020
+```
+
+### リトライ戦略の比較
+
+#### 代表 3 言語
+
+**Scala**: orElse の fold
+
+```scala
+def retry[A](action: IO[A], maxRetries: Int): IO[A] =
+  List.range(0, maxRetries)
+    .map(_ => action)
+    .foldLeft(action)((program, retryAction) =>
+      program.orElse(retryAction))
+```
+
+**Haskell**: 再帰 + try/catch
+
+```haskell
+retryIO :: Int -> IO a -> IO (Maybe a)
+retryIO 0 _      = return Nothing
+retryIO n action = do
+    result <- try action :: IO (Either SomeException a)
+    case result of
+        Right a -> return (Just a)
+        Left _  -> retryIO (n - 1) action
+```
+
+**Rust**: ジェネリック関数 + Result
+
+```rust
+pub async fn retry<T, E, F, Fut>(action: F, max_retries: usize) -> Result<T, E>
+where
+    F: Fn() -> Fut,
+    Fut: Future<Output = Result<T, E>>,
+{
+    let mut last_error = None;
+    for _ in 0..max_retries {
+        match action().await {
+            Ok(result) => return Ok(result),
+            Err(e) => last_error = Some(e),
+        }
+    }
+    Err(last_error.unwrap())
+}
+```
+
+### 全 11 言語のエラーハンドリング比較
+
+| 言語 | フォールバック | リトライ方式 | エラー型 |
+|------|-------------|------------|---------|
+| **Haskell** | `catch` / 手動 | 再帰 + `try` | `SomeException` |
+| **Scala** | `IO.orElse` | fold / handleErrorWith | `Throwable` |
+| **Rust** | `or_else` / `unwrap_or` | ループ + `Result` | `E` (ジェネリック) |
+| **F#** | `try/with` + Async | Async.Catch | `exn` |
+| **C#** | `try/catch` + Task | ループ + try/catch | `Exception` |
+| **TypeScript** | `TaskEither` + `orElse` | pipe + orElse | `E` (ジェネリック) |
+| **Java** | try/catch 内 IO | ループ + try/catch | `Exception` |
+| **Python** | try/except 内 LazyIO | ループ + try/except | `Exception` |
+| **Ruby** | `or_else` ブロック | ループ + rescue | `StandardError` |
+| **Clojure** | `try/catch` | 再帰 + try/catch | Java 例外 |
+| **Elixir** | `or_else` 関数 | 再帰 + rescue | `RuntimeError` |
+
+---
+
+## 8.7 sequence：IO のリスト変換
+
+`List[IO[A]]` → `IO[List[A]]` の変換は、複数の IO を一つにまとめる重要なパターンです。
+
+### 代表的な実装
+
+```scala
+// Scala: cats の sequence
+import cats.implicits._
+
+val actions: List[IO[Int]] = List(IO.pure(1), IO.pure(2), IO.pure(3))
+val combined: IO[List[Int]] = actions.sequence
+combined.unsafeRunSync()  // List(1, 2, 3)
+
+// 複数人の予定を取得
+def scheduledMeetings(attendees: List[String]): IO[List[MeetingTime]] =
+  attendees
+    .map(attendee => retry(calendarEntries(attendee), 10))
+    .sequence
+    .map(_.flatten)
+```
+
+```haskell
+-- Haskell: sequence（標準ライブラリ）
+sequenceIO :: [IO a] -> IO [a]
+sequenceIO []     = return []
+sequenceIO (x:xs) = do
+    a  <- x
+    as <- sequenceIO xs
+    return (a : as)
+
+-- replicateM で n 回実行
+castTheDieN :: Int -> IO [Int]
+castTheDieN n = replicateM n castTheDie
+```
+
+```rust
+// Rust: join_all で並行実行
+pub async fn scheduled_meetings_for_all(attendees: &[&str]) -> Vec<MeetingTime> {
+    let futures: Vec<_> = attendees
+        .iter()
+        .map(|name| calendar_entries(name))
+        .collect();
+
+    let results = futures::future::join_all(futures).await;
+    results.into_iter().flatten().collect()
+}
+```
+
+### 語彙比較
+
+| 言語 | List[IO[A]] → IO[List[A]] | 並行実行 |
+|------|--------------------------|---------|
+| **Haskell** | `sequence` / `mapM` | `mapConcurrently` |
+| **Scala** | `.sequence` (cats) | `parSequence` |
+| **Rust** | `join_all` / `try_join_all` | `join_all`（デフォルト並行） |
+| **F#** | `Async.Parallel` | `Async.Parallel`（デフォルト並行） |
+| **C#** | `Task.WhenAll` | `Task.WhenAll`（デフォルト並行） |
+| **TypeScript** | `array.sequence(T.task)` | `Promise.all` |
+| **Java** | 手動 flatMap ループ | `CompletableFuture.allOf` |
+| **Python** | 手動 bind ループ | `asyncio.gather` |
+| **Ruby** | 手動 bind ループ | `Thread` / `Ractor` |
+| **Clojure** | `(doall (map deref ...))` | `pmap` |
+| **Elixir** | 手動 fold | `Task.async_stream` |
+
+---
+
+## 8.8 比較分析：3 つの発見
+
+### 発見 1: IO の抽象化レベルは 4 段階に分かれる
+
+```plantuml
+@startuml
+!theme plain
+left to right direction
+
+rectangle "Level 1: 言語組み込み IO" #LightGreen {
+  card "Haskell (IO モナド)" as h
+}
+
+rectangle "Level 2: エフェクトライブラリ" #LightBlue {
+  card "Scala (cats-effect IO)" as sc
+  card "TypeScript (fp-ts IO/Task)" as ts
+}
+
+rectangle "Level 3: 言語の非同期プリミティブ" #LightYellow {
+  card "F# (Async)" as fs
+  card "C# (Task)" as cs
+  card "Rust (Future / async)" as rs
+}
+
+rectangle "Level 4: 慣習的分離 / 自前実装" #LightCoral {
+  card "Java (カスタム IO)" as jv
+  card "Python (LazyIO)" as py
+  card "Ruby (カスタム IO)" as rb
+  card "Clojure (delay/atom)" as clj
+  card "Elixir (無名関数)" as ex
+}
+
+@enduml
+```
+
+**Level 1（Haskell）** は言語レベルで純粋性を保証します。IO 型を持たない関数は副作用を起こせないため、型シグネチャだけで純粋性がわかります。
+
+**Level 2（Scala, TypeScript）** はライブラリが IO 型を提供し、`unsafeRunSync` / `io()` で実行を明示します。純粋性はライブラリの規約に依存します。
+
+**Level 3（F#, C#, Rust）** は言語の非同期プリミティブ（`Async`, `Task`, `Future`）で副作用を遅延実行します。IO モナドとは異なりますが、「記述と実行の分離」を実現しています。
+
+**Level 4（Java, Python, Ruby, Clojure, Elixir）** は標準的な IO 型がなく、カスタム実装または慣習的な分離に頼ります。
+
+### 発見 2: 合成構文は 3 系統に分かれる
+
+| 系統 | 構文 | 言語 | 可読性 |
+|------|------|------|--------|
+| **モナド内包表記** | do / for / async { } / LINQ | Haskell, Scala, F#, C# | 高（手続き的に読める） |
+| **async/await** | async fn / await | C#, Rust, F# | 高（主流の構文） |
+| **明示的チェーン** | flatMap / bind / chain | Java, Python, Ruby, TypeScript, Elixir, Clojure | 低〜中（ラムダのネスト） |
+
+モナド内包表記と async/await は本質的に同じ脱糖を行います：
+
+```
+-- Haskell do 記法の脱糖
+do { x <- io1; y <- io2; return (x + y) }
+  ≡ io1 >>= \x -> io2 >>= \y -> return (x + y)
+
+-- C# async/await の脱糖
+async { var x = await task1; var y = await task2; return x + y; }
+  ≡ task1.ContinueWith(x => task2.ContinueWith(y => x + y))
+```
+
+### 発見 3: 純粋コア / 不純シェルはすべての言語で有効
+
+IO の抽象化レベルに関わらず、**Pure Core / Impure Shell** パターンはすべての言語で適用できます：
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "Pure Core / Impure Shell" {
+  rectangle "Impure Shell（IO 境界）" #LightCoral {
+    rectangle "Pure Core（純粋ロジック）" #LightGreen {
+      card "meetingsOverlap" as overlap
+      card "possibleMeetings" as possible
+      card "parseAndValidate" as parse
+    }
+
+    card "calendarEntries" as cal
+    card "createMeeting" as create
+    card "getLine / putStrLn" as stdio
+  }
+
+  cal --> possible : データを渡す
+  possible --> create : 結果を渡す
+  stdio --> parse : 入力を渡す
+}
+
+note bottom
+  ビジネスロジックは純粋関数で
+  IO は境界部分のみ
+end note
+
+@enduml
+```
+
+```haskell
+-- Haskell: 純粋関数と IO の明確な分離
+-- 純粋関数（テスト容易）
+possibleMeetings :: [MeetingTime] -> Int -> Int -> Int -> [MeetingTime]
+possibleMeetings existingMeetings startHour endHour lengthHours =
+    let slots = [MeetingTime s (s + lengthHours) | s <- [startHour .. endHour - lengthHours]]
+    in filter (\slot -> all (not . meetingsOverlap slot) existingMeetings) slots
+
+-- IO 関数（外部 API）
+calendarEntries :: String -> IO [MeetingTime]
+scheduledMeetings :: String -> String -> IO [MeetingTime]
+```
+
+---
+
+## 8.9 言語固有の特徴
+
+### Haskell: IO の純粋性保証
+
+Haskell は唯一、**型シグネチャで純粋性を保証**する言語です：
+
+```haskell
+-- 純粋関数（IO なし）：副作用は不可能
+possibleMeetings :: [MeetingTime] -> Int -> Int -> Int -> [MeetingTime]
+
+-- IO 関数：副作用があることが明示的
+calendarEntries :: String -> IO [MeetingTime]
+```
+
+コンパイラが純粋関数内の IO 使用を禁止するため、「うっかり副作用を混入」という事故が起きません。
+
+### Rust: ゼロコスト抽象化の async/await
+
+Rust の `async fn` はコンパイル時にステートマシンに変換され、ランタイムオーバーヘッドがゼロです：
+
+```rust
+// コンパイル後、ヒープ割り当てなしのステートマシンに変換
+pub async fn scheduled_meetings(person1: &str, person2: &str) -> Vec<MeetingTime> {
+    let entries1 = calendar_entries(person1).await;
+    let entries2 = calendar_entries(person2).await;
+    [entries1, entries2].concat()
+}
+```
+
+### TypeScript: IO / Task / TaskEither の 3 層
+
+fp-ts は同期・非同期・エラー付き非同期の 3 つの IO 型を提供します：
+
+```typescript
+import * as IO from 'fp-ts/IO'         // 同期 IO
+import * as T from 'fp-ts/Task'         // 非同期 IO（成功のみ）
+import * as TE from 'fp-ts/TaskEither'  // 非同期 IO（エラーあり）
+
+// IO<A>:     () => A
+// Task<A>:   () => Promise<A>
+// TaskEither<E, A>: () => Promise<Either<E, A>>
+```
+
+### Clojure: 複数プリミティブの使い分け
+
+Clojure は単一の IO 型ではなく、用途別のプリミティブを使い分けます：
+
+```clojure
+;; delay: 遅延評価（キャッシュあり）
+(def lazy-val (delay (expensive-computation)))
+
+;; atom: 状態管理（同期的な更新）
+(def state (atom {:count 0}))
+(swap! state update :count inc)
+
+;; future: 非同期計算（別スレッド）
+(def async-result (future (api-call)))
+@async-result  ; 結果を待つ
+```
+
+### Elixir: OTP プロセスとの統合
+
+Elixir は無名関数に加え、`Agent` と `Task` で状態管理と非同期処理を OTP の軽量プロセスで実現します：
+
+```elixir
+# Agent: 状態管理（プロセス内）
+{:ok, agent} = Agent.start_link(fn -> %{} end)
+Agent.update(agent, fn state -> Map.put(state, :key, "value") end)
+
+# Task: 非同期処理（並行プロセス）
+task = Task.async(fn -> expensive_computation() end)
+result = Task.await(task)
+```
+
+---
+
+## 8.10 実践的な選択指針
+
+### IO の抽象化レベルの選択
+
+| 要件 | 推奨言語 | 理由 |
+|------|---------|------|
+| 最も厳格な純粋性保証 | Haskell | 型レベルで IO と純粋関数を分離 |
+| 高性能な非同期処理 | Rust | ゼロコスト抽象化の async/await |
+| JVM でのエフェクト管理 | Scala + cats-effect | 成熟した IO ライブラリ |
+| .NET での非同期処理 | F# (Async) / C# (Task) | コンピュテーション式 / async-await |
+| フロントエンドでの型安全 IO | TypeScript + fp-ts | IO / Task / TaskEither の 3 層 |
+| 分散システム | Elixir | OTP の軽量プロセスモデル |
+| 並行状態管理 | Clojure | atom / ref / STM |
+
+### プロジェクト規模別の推奨
+
+| 規模 | 推奨アプローチ | 言語例 |
+|------|-------------|-------|
+| 小規模 | Pure Core / Impure Shell の慣習的分離 | Python, Ruby, Java |
+| 中規模 | エフェクトライブラリの導入 | Scala (cats-effect), TypeScript (fp-ts) |
+| 大規模 | 言語レベルの IO 分離 | Haskell, F# |
+
+---
+
+## 8.11 まとめ
+
+本章では、11 言語での IO モナドと副作用の分離を比較し、以下を確認しました：
+
+**共通の原則**:
+
+- IO = 副作用の「記述」と「実行」の分離
+- flatMap / bind / chain による IO の合成
+- Pure Core / Impure Shell パターンはすべての言語で有効
+
+**言語間の差異**:
+
+- 抽象化レベルは 4 段階（言語組み込み → ライブラリ → 非同期プリミティブ → 慣習的分離）
+- 合成構文は 3 系統（モナド内包表記 / async-await / 明示的チェーン）
+- Haskell のみが型レベルで純粋性を保証
+
+**学び**:
+
+- 副作用の管理は「型で表現する」か「慣習で分離する」かの選択
+- async/await は IO モナドの脱糖と本質的に同じ
+- エラーハンドリングとリトライは IO の合成で自然に表現できる
+
+---
+
+### 各言語の詳細記事
+
+| 言語 | 記事リンク |
+|------|-----------|
+| Scala | [Part IV: IO と副作用の管理](../scala/part-4.md) |
+| Java | [Part IV: IO と副作用の管理](../java/part-4.md) |
+| F# | [Part IV: 非同期処理とストリーム](../fsharp/part-4.md) |
+| C# | [Part IV: 非同期処理とストリーム](../csharp/part-4.md) |
+| Haskell | [Part IV: IO と副作用の管理](../haskell/part-4.md) |
+| Clojure | [Part IV: 状態管理とストリーム処理](../clojure/part-4.md) |
+| Elixir | [Part IV: IO とストリーム処理](../elixir/part-4.md) |
+| Rust | [Part IV: 非同期処理とストリーム](../rust/part-4.md) |
+| Python | [Part IV: IO と副作用の管理](../python/part-4.md) |
+| TypeScript | [Part IV: IO と副作用の管理](../typescript/part-4.md) |
+| Ruby | [Part IV: IO と副作用の管理](../ruby/part-4.md) |