@k2works/claude-code-booster 4.13.0 → 4.15.0

package/lib/assets/docs/article/grokkingfp/elixir/part-4.md

@@ -1,974 +1,974 @@
-# Part IV: IO とストリーム処理
-
-本章では、関数型プログラミングにおける副作用の扱い方を学びます。Elixir の無名関数を使って副作用を遅延実行し、Stream モジュールで無限のデータを効率的に扱う方法を習得します。
-
----
-
-## 第8章: IO パターンとプロセス
-
-### 8.1 副作用の問題
-
-純粋関数は副作用を持ちません。しかし、実際のプログラムには副作用が必要です:
-
-- ファイルの読み書き
-- ネットワーク通信
-- データベースアクセス
-- 乱数生成
-- 現在時刻の取得
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "副作用の問題" {
-  rectangle "副作用を持つ関数" as impure {
-    card "テストが困難"
-    card "予測不可能"
-    card "参照透過性がない"
-  }
-
-  rectangle "純粋関数" as pure {
-    card "テストが容易"
-    card "予測可能"
-    card "参照透過性がある"
-  }
-}
-
-note bottom
-  どうすれば副作用を
-  純粋関数のように扱えるか？
-end note
-
-@enduml
-```
-
-### 8.2 Elixir における IO パターン
-
-Scala の `IO` モナドに相当する概念を、Elixir では**無名関数**を使って表現します。
-
-- `fn -> expr end` は「実行すると結果を返す副作用のある計算」
-- 関数を作成しただけでは副作用は発生しない
-- 関数を呼び出すことで実際に実行される
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "遅延実行パターンの仕組み" {
-  card "delay(fn -> 副作用 end)" as create
-  card "関数値" as io
-  card "run(io)" as run
-  card "副作用が実行される" as effect
-
-  create --> io : 記述を作成
-  io --> run : 実行を指示
-  run --> effect : 実際に実行
-}
-
-note bottom of io
-  この時点では
-  副作用は発生しない
-end note
-
-@enduml
-```
-
-### 8.3 サイコロを振る例
-
-**ソースファイル**: `app/elixir/lib/ch08/io_and_processes.ex`
-
-#### 不純な関数（副作用あり）
-
-```elixir
-def cast_the_die_impure do
-  :rand.uniform(6)
-end
-
-# 呼び出すたびに異なる値が返る
-IO.inspect(cast_the_die_impure())  # 3
-IO.inspect(cast_the_die_impure())  # 5
-IO.inspect(cast_the_die_impure())  # 1
-```
-
-#### 遅延実行パターン
-
-```elixir
-@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
-
-# 関数を作成（この時点では実行されない）
-die_cast = cast_the_die()
-IO.inspect(die_cast)  # #Function<...> - まだ実行されていない
-
-# 実際に実行
-IO.inspect(run(die_cast))  # 4
-```
-
-### 8.4 IO の作成方法
-
-| 関数 | 用途 | 例 |
-|------|------|-----|
-| `delay(f)` | 副作用のある式をラップ | `delay(fn -> IO.puts("hello") end)` |
-| `pure(value)` | 既存の値をラップ（副作用なし） | `pure(42)` |
-
-```elixir
-# delay: 副作用を遅延実行
-delayed_print = delay(fn -> IO.puts("Hello") end)
-# IO.puts はまだ実行されていない
-
-# pure: 既存の値をラップ
-pure_value = pure(42)
-# 副作用なし、即座に 42 が確定
-```
-
-### 8.5 IO の合成
-
-IO 値は `flat_map` でチェーンできます。Scala の `for` 内包表記に相当します。
-
-```elixir
-@spec flat_map((-> any()), (any() -> (-> any()))) :: (-> any())
-def flat_map(io, f) do
-  fn ->
-    result = run(io)
-    run(f.(result))
-  end
-end
-
-def cast_the_die_twice do
-  flat_map(cast_the_die(), fn first ->
-    map(cast_the_die(), fn second ->
-      first + second
-    end)
-  end)
-end
-
-# まだ実行されていない
-program = cast_the_die_twice()
-
-# 実行
-result = run(program)  # 2〜12 の値
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "IO の合成" {
-  card "cast_the_die()" as cast1
-  card "cast_the_die()" as cast2
-  card "first + second" as combine
-
-  cast1 --> combine : flat_map
-  cast2 --> combine : map
-}
-
-note bottom
-  flat_map でチェーンして
-  順序付けて合成
-end note
-
-@enduml
-```
-
-### 8.6 ミーティングスケジューリングの例
-
-より実践的な例として、ミーティングのスケジューリングを見てみましょう。
-
-```elixir
-defmodule MeetingTime do
-  defstruct [:start_hour, :end_hour]
-end
-
-# 副作用のある API 呼び出しを遅延実行
-def calendar_entries(name) do
-  delay(fn ->
-    # モックデータ（実際には API 呼び出し）
-    case name do
-      "Alice" -> [%MeetingTime{start_hour: 9, end_hour: 10}, ...]
-      "Bob" -> [%MeetingTime{start_hour: 10, end_hour: 11}, ...]
-      _ -> []
-    end
-  end)
-end
-```
-
-#### 予定の取得
-
-```elixir
-def scheduled_meetings(person1, person2) do
-  flat_map(calendar_entries(person1), fn entries1 ->
-    map(calendar_entries(person2), fn entries2 ->
-      entries1 ++ entries2
-    end)
-  end)
-end
-
-# 使用例
-io = scheduled_meetings("Alice", "Bob")
-meetings = run(io)  # 4件の予定
-```
-
-#### 空き時間の計算（純粋関数）
-
-```elixir
-def possible_meetings(existing_meetings, start_hour, end_hour, length_hours) do
-  slots =
-    start_hour..(end_hour - length_hours)
-    |> Enum.map(fn start ->
-      %MeetingTime{start_hour: start, end_hour: start + length_hours}
-    end)
-
-  Enum.filter(slots, fn slot ->
-    Enum.all?(existing_meetings, fn meeting ->
-      not meetings_overlap?(meeting, slot)
-    end)
-  end)
-end
-
-# ミーティングが重なるかチェック
-def meetings_overlap?(m1, m2) do
-  m1.start_hour < m2.end_hour && m2.start_hour < m1.end_hour
-end
-```
-
-### 8.7 or_else によるエラーハンドリング
-
-`or_else` 関数で、失敗時のフォールバックを指定できます。
-
-```elixir
-def or_else(io, fallback) do
-  fn ->
-    try do
-      run(io)
-    rescue
-      _ -> run(fallback)
-    end
-  end
-end
-
-success = pure(42)
-fallback = pure(0)
-run(or_else(success, fallback))  # 42
-
-failing = fn -> raise "error" end
-run(or_else(failing, fallback))  # 0
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "or_else の動作" {
-  card "メインの IO" as main
-  card "フォールバック IO" as fallback
-  card "結果" as result
-
-  main --> result : 成功時
-  main --> fallback : 失敗時
-  fallback --> result
-}
-
-@enduml
-```
-
-#### リトライ戦略
-
-```elixir
-def retry(io, max_retries) do
-  fn ->
-    do_retry(io, max_retries, nil)
-  end
-end
-
-defp do_retry(_io, 0, last_error), do: raise(last_error || "Max retries exceeded")
-
-defp do_retry(io, retries_left, _last_error) do
-  try do
-    run(io)
-  rescue
-    e -> do_retry(io, retries_left - 1, e)
-  end
-end
-
-# 使用例：API 呼び出しを5回までリトライ
-result = retry(calendar_entries("Alice"), 5)
-```
-
-### 8.8 sequence による IO のリスト処理
-
-`[IO]` を `IO[List]` に変換するには `sequence` を使います。
-
-```elixir
-def sequence(ios) do
-  fn -> Enum.map(ios, &run/1) end
-end
-
-ios = [pure(1), pure(2), pure(3)]
-combined = sequence(ios)
-run(combined)  # [1, 2, 3]
-```
-
-#### 複数人の予定を取得
-
-```elixir
-def scheduled_meetings_for(attendees) do
-  attendees
-  |> Enum.map(&calendar_entries/1)
-  |> sequence()
-  |> map(&List.flatten/1)
-end
-
-# 使用例
-io = scheduled_meetings_for(["Alice", "Bob"])
-meetings = run(io)  # 4件の予定
-```
-
-### 8.9 Agent による状態管理
-
-Elixir では `Agent` を使って状態を安全に管理できます。
-
-```elixir
-def create_counter(initial_value) do
-  Agent.start_link(fn -> initial_value end)
-end
-
-def get_count(counter) do
-  Agent.get(counter, & &1)
-end
-
-def increment(counter) do
-  Agent.update(counter, &(&1 + 1))
-end
-
-# 使用例
-{:ok, counter} = create_counter(0)
-get_count(counter)  # 0
-increment(counter)
-get_count(counter)  # 1
-```
-
-### 8.10 Task による非同期処理
-
-`Task` を使って非同期処理を実行できます。
-
-```elixir
-def async_calendar_entries(name) do
-  Task.async(fn -> run(calendar_entries(name)) end)
-end
-
-def parallel_calendar_entries(names) do
-  names
-  |> Enum.map(&async_calendar_entries/1)
-  |> Task.await_many()
-  |> List.flatten()
-end
-
-# 使用例：並行でカレンダーを取得
-entries = parallel_calendar_entries(["Alice", "Bob"])  # 4件
-```
-
----
-
-## 第9章: ストリーム処理
-
-### 9.1 ストリームとは
-
-**ストリーム**は、要素の（潜在的に無限の）シーケンスを遅延評価で表します。Elixir の `Stream` モジュールを使用します。
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "List vs Stream" {
-  rectangle "List" as list {
-    card "全要素がメモリに存在"
-    card "有限"
-    card "即座に評価"
-  }
-
-  rectangle "Stream" as stream {
-    card "必要な時に要素を生成"
-    card "無限も可能"
-    card "遅延評価"
-  }
-}
-
-@enduml
-```
-
-### 9.2 基本的なストリーム操作
-
-**ソースファイル**: `app/elixir/lib/ch09/streams.ex`
-
-```elixir
-# 有限ストリーム
-def finite_stream(list), do: Stream.map(list, & &1)
-
-stream = finite_stream([1, 2, 3])
-Enum.to_list(stream)  # [1, 2, 3]
-
-# フィルタリング
-def filter_stream(stream, predicate), do: Stream.filter(stream, predicate)
-
-odd_numbers = filter_stream([1, 2, 3, 4, 5], &(rem(&1, 2) != 0))
-Enum.to_list(odd_numbers)  # [1, 3, 5]
-```
-
-### 9.3 無限ストリーム
-
-```elixir
-# 無限に繰り返し
-def repeat(list), do: Stream.cycle(list)
-
-infinite = repeat([1, 2, 3])
-Enum.take(infinite, 8)  # [1, 2, 3, 1, 2, 3, 1, 2]
-
-# 生成関数を使用
-def generate(f), do: Stream.repeatedly(f)
-
-stream = generate(fn -> :rand.uniform(6) end)
-Enum.take(stream, 5)  # [4, 2, 6, 1, 3]
-
-# カウントアップ
-def count_from(start), do: Stream.iterate(start, &(&1 + 1))
-
-stream = count_from(1)
-Enum.take(stream, 5)  # [1, 2, 3, 4, 5]
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "無限ストリーム" {
-  card "Stream.cycle([1, 2, 3])" as stream
-  card "1, 2, 3, 1, 2, 3, 1, 2, 3, ..." as infinite
-  card "Enum.take(8)" as take
-  card "[1, 2, 3, 1, 2, 3, 1, 2]" as result
-
-  stream --> infinite
-  infinite --> take
-  take --> result
-}
-
-note bottom
-  無限のストリームから
-  必要な分だけ取得
-end note
-
-@enduml
-```
-
-### 9.4 サイコロストリーム
-
-```elixir
-def die_casts do
-  Stream.repeatedly(fn -> :rand.uniform(6) end)
-end
-
-# 最初の3回を取得
-die_casts() |> Enum.take(3)  # [4, 2, 6]
-
-# 6 が出るまで振り続ける
-def roll_until(target) do
-  die_casts()
-  |> Stream.take_while(fn x -> x != target end)
-  |> Enum.to_list()
-  |> Kernel.++([target])
-end
-
-roll_until(6)  # [2, 4, 1, 3, 6]
-
-# 指定回数振って合計
-def roll_and_sum(n) do
-  die_casts()
-  |> Enum.take(n)
-  |> Enum.sum()
-end
-
-roll_and_sum(3)  # 3〜18 の値
-```
-
-### 9.5 ストリームの主要操作
-
-| 操作 | 説明 | 例 |
-|------|------|-----|
-| `Stream.take(n)` | 最初の n 要素を取得 | `stream \|> Stream.take(3)` |
-| `Stream.filter(p)` | 条件を満たす要素のみ | `stream \|> Stream.filter(&(&1 > 0))` |
-| `Stream.map(f)` | 各要素を変換 | `stream \|> Stream.map(&(&1 * 2))` |
-| `Stream.concat(s)` | 別のストリームを結合 | `Stream.concat(s1, s2)` |
-| `Stream.cycle(list)` | 無限に繰り返し | `Stream.cycle([1, 2, 3])` |
-| `Stream.chunk_every(n, step)` | スライディングウィンドウ | `stream \|> Stream.chunk_every(3, 1)` |
-
-### 9.6 通貨交換レートの例
-
-為替レートを監視して、上昇トレンドを検出する例です。
-
-#### トレンド判定（純粋関数）
-
-```elixir
-def trending?(rates) when length(rates) <= 1, do: false
-
-def trending?(rates) do
-  rates
-  |> Enum.zip(Enum.drop(rates, 1))
-  |> Enum.all?(fn {prev, curr} -> curr > prev end)
-end
-
-trending?([0.81, 0.82, 0.83])  # true (上昇トレンド)
-trending?([0.81, 0.84, 0.83])  # false
-
-def declining?(rates) when length(rates) <= 1, do: false
-
-def declining?(rates) do
-  rates
-  |> Enum.zip(Enum.drop(rates, 1))
-  |> Enum.all?(fn {prev, curr} -> curr < prev end)
-end
-
-declining?([0.83, 0.82, 0.81])  # true (下降トレンド)
-
-def stable?(values) when length(values) < 3, do: false
-
-def stable?(values) do
-  values |> Enum.uniq() |> length() == 1
-end
-
-stable?([5, 5, 5])  # true (安定)
-```
-
-#### レートのストリーム
-
-```elixir
-def exchange_rate(from, to) do
-  # モックの為替レート（実際には API を呼び出す）
-  base_rates = %{
-    {:usd, :eur} => 0.85,
-    {:usd, :gbp} => 0.73,
-    # ...
-  }
-
-  base_rate = Map.get(base_rates, {from, to}, 1.0)
-  variation = (:rand.uniform() - 0.5) * 0.02
-  base_rate * (1 + variation)
-end
-
-def rate_stream(from, to) do
-  Stream.repeatedly(fn -> exchange_rate(from, to) end)
-end
-
-# 使用例
-rate_stream(:usd, :eur) |> Enum.take(3)
-# [0.8493, 0.8521, 0.8478]
-```
-
-### 9.7 スライディングウィンドウ
-
-`Stream.chunk_every/4` で連続する要素をグループ化できます。
-
-```elixir
-def sliding(stream, size) do
-  Stream.chunk_every(stream, size, 1, :discard)
-end
-
-sliding([1, 2, 3, 4, 5], 3) |> Enum.to_list()
-# [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "sliding(3) の動作" {
-  card "[1, 2, 3, 4, 5]" as input
-  card "[1, 2, 3]" as w1
-  card "[2, 3, 4]" as w2
-  card "[3, 4, 5]" as w3
-
-  input --> w1
-  input --> w2
-  input --> w3
-}
-
-@enduml
-```
-
-#### トレンドを検出して交換
-
-```elixir
-def exchange_if_trending(amount, from, to, window_size, max_attempts) do
-  result =
-    rate_stream(from, to)
-    |> sliding(window_size)
-    |> Stream.filter(&trending?/1)     # 上昇トレンドを検出
-    |> Stream.map(&List.last/1)        # 最新のレートを取得
-    |> Stream.take(1)
-    |> Enum.take(max_attempts)
-    |> List.first()
-
-  case result do
-    nil -> {:error, "No trending pattern found"}
-    rate -> {:ok, rate * amount}
-  end
-end
-
-# 使用例
-exchange_if_trending(100.0, :usd, :eur, 3, 1000)
-# {:ok, 85.23}
-```
-
-### 9.8 ストリームの結合
-
-2つのストリームを `Stream.zip` で結合できます。
-
-```elixir
-def zip_streams(stream1, stream2) do
-  Stream.zip(stream1, stream2)
-end
-
-zip_streams([1, 2, 3], ["a", "b", "c"]) |> Enum.to_list()
-# [{1, "a"}, {2, "b"}, {3, "c"}]
-
-# 左側の値だけ返す
-def zip_left(stream1, stream2) do
-  Stream.zip(stream1, stream2)
-  |> Stream.map(fn {left, _right} -> left end)
-end
-
-# インターバル付きで処理
-def with_interval(stream, interval_ms) do
-  Stream.map(stream, fn item ->
-    Process.sleep(interval_ms)
-    item
-  end)
-end
-
-# レートを1秒間隔で取得
-rate_stream(:usd, :eur)
-|> with_interval(1000)
-|> Enum.take(5)
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "zip_left の動作" {
-  card "rates: [0.81, 0.82, 0.83, ...]" as rates
-  card "ticks: [:tick, :tick, :tick, ...]" as ticks
-  card "zip_left" as zip
-  card "[0.81, 0.82, 0.83, ...] (1秒間隔)" as result
-
-  rates --> zip
-  ticks --> zip
-  zip --> result
-}
-
-note bottom
-  左側の値を返しつつ
-  右側のペースで進む
-end note
-
-@enduml
-```
-
-### 9.9 集計操作
-
-```elixir
-# 合計
-def sum_stream(stream), do: Enum.sum(stream)
-
-sum_stream([1, 2, 3, 4, 5])  # 15
-
-# 平均
-def average_stream(stream) do
-  {sum, count} =
-    Enum.reduce(stream, {0, 0}, fn x, {sum, count} ->
-      {sum + x, count + 1}
-    end)
-
-  if count == 0, do: 0.0, else: sum / count
-end
-
-average_stream([1, 2, 3, 4, 5])  # 3.0
-
-# 移動平均
-def moving_average(stream, window_size) do
-  stream
-  |> sliding(window_size)
-  |> Stream.map(&average_stream/1)
-end
-
-moving_average([1, 2, 3, 4, 5], 3) |> Enum.to_list()
-# [2.0, 3.0, 4.0]
-```
-
-### 9.10 unfold によるストリーム生成
-
-`Stream.unfold/2` で状態を持つストリームを生成できます。
-
-```elixir
-# フィボナッチ数列
-def fibonacci do
-  Stream.unfold({0, 1}, fn {a, b} ->
-    {a, {b, a + b}}
-  end)
-end
-
-fibonacci() |> Enum.take(10)
-# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
-
-# 等比数列
-def geometric_series(start, ratio) do
-  Stream.unfold(start, fn current ->
-    {current, current * ratio}
-  end)
-end
-
-geometric_series(1, 2) |> Enum.take(5)
-# [1, 2, 4, 8, 16]
-
-# 等差数列
-def arithmetic_series(start, diff) do
-  Stream.unfold(start, fn current ->
-    {current, current + diff}
-  end)
-end
-
-arithmetic_series(1, 3) |> Enum.take(5)
-# [1, 4, 7, 10, 13]
-```
-
----
-
-## まとめ
-
-### Part IV で学んだこと
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "Part IV: IO とストリーム処理" {
-  rectangle "第8章" as ch8 {
-    card "遅延実行パターン"
-    card "delay / run"
-    card "flat_map / map"
-    card "or_else / retry"
-    card "sequence"
-    card "Agent / Task"
-  }
-
-  rectangle "第9章" as ch9 {
-    card "Elixir Stream"
-    card "無限ストリーム"
-    card "cycle / take"
-    card "sliding"
-    card "zip / zip_left"
-    card "unfold"
-  }
-}
-
-ch8 --> ch9
-
-@enduml
-```
-
-### Scala との対応
-
-| Scala | Elixir |
-|-------|--------|
-| `IO[A]` | `(-> any())` (無名関数) |
-| `IO.delay(expr)` | `delay(fn -> expr end)` |
-| `IO.pure(value)` | `pure(value)` |
-| `unsafeRunSync()` | `run(io)` |
-| `flatMap` | `flat_map/2` |
-| `orElse` | `or_else/2` |
-| `sequence` | `sequence/1` |
-| `fs2.Stream` | `Stream` モジュール |
-| `Stream.eval` | `Stream.repeatedly` |
-| `sliding(n)` | `Stream.chunk_every(n, 1, :discard)` |
-| `zipLeft` | `zip_left/2` |
-
-### キーポイント
-
-1. **遅延実行パターン**: 副作用を「記述」として扱い、実行を遅延させる
-2. **delay/run**: 副作用のある式を遅延実行
-3. **or_else**: 失敗時のフォールバックを指定
-4. **sequence**: `[IO]` → `IO[List]`
-5. **Stream**: 潜在的に無限のシーケンスを遅延評価で処理
-6. **sliding**: 連続する要素をグループ化してパターンを検出
-7. **unfold**: 状態を持つストリームを生成
-
-### Elixir の特徴
-
-- **Agent**: プロセスベースの状態管理
-- **Task**: 簡単な非同期処理
-- **Stream**: 組み込みの遅延評価ストリーム
-
-### 次のステップ
-
-Part V では、以下のトピックを学びます:
-
-- 並行・並列処理
-- GenServer による状態管理
-- Supervisor による耐障害性
-
----
-
-## 演習問題
-
-### 問題 1: IO の基本
-
-以下の関数を実装してください。
-
-```elixir
-def print_and_return(message) do
-  # メッセージを出力して、そのメッセージを返す IO を作成
-  ???
-end
-
-# 期待される動作
-# io = print_and_return("Hello")
-# run(io) は "Hello" をコンソールに出力し、"Hello" を返す
-```
-
-<details>
-<summary>解答</summary>
-
-```elixir
-def print_and_return(message) do
-  delay(fn ->
-    IO.puts(message)
-    message
-  end)
-end
-```
-
-</details>
-
-### 問題 2: IO の合成
-
-以下の関数を実装してください。2つの IO を順番に実行し、結果を結合します。
-
-```elixir
-def combine_io(io1, io2, f) do
-  # io1 と io2 を実行し、結果を f で結合
-  ???
-end
-
-# 期待される動作
-# io = combine_io(pure(1), pure(2), &(&1 + &2))
-# run(io)  # 3
-```
-
-<details>
-<summary>解答</summary>
-
-```elixir
-def combine_io(io1, io2, f) do
-  flat_map(io1, fn a ->
-    map(io2, fn b ->
-      f.(a, b)
-    end)
-  end)
-end
-```
-
-</details>
-
-### 問題 3: リトライ
-
-以下の関数を実装してください。指定回数リトライし、全部失敗したらデフォルト値を返します。
-
-```elixir
-def retry_with_default(io, max_retries, default) do
-  ???
-end
-```
-
-<details>
-<summary>解答</summary>
-
-```elixir
-def retry_with_default(io, max_retries, default) do
-  fn ->
-    try do
-      run(retry(io, max_retries))
-    rescue
-      _ -> default
-    end
-  end
-end
-```
-
-</details>
-
-### 問題 4: ストリーム操作
-
-以下のストリームを作成してください。
-
-```elixir
-# 1. 1から10までの偶数のストリーム
-evens = ???
-
-# 2. 無限に交互に true/false を返すストリーム
-alternating = ???
-
-# 3. 最初の5つの要素の合計を計算
-sum = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |> Stream.take(5) |> ???
-```
-
-<details>
-<summary>解答</summary>
-
-```elixir
-# 1. 1から10までの偶数
-evens = 1..10 |> Stream.filter(&(rem(&1, 2) == 0))
-# または
-evens = Stream.iterate(2, &(&1 + 2)) |> Stream.take_while(&(&1 <= 10))
-
-# 2. 無限に交互に true/false
-alternating = Stream.cycle([true, false])
-
-# 3. 最初の5つの要素の合計
-sum = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |> Stream.take(5) |> Enum.sum()  # 15
-```
-
-</details>
-
-### 問題 5: トレンド検出
-
-以下の関数を実装してください。直近3つの値が全て同じかどうかを判定します。
-
-```elixir
-def stable?(values) do
-  ???
-end
-
-# 期待される動作
-assert stable?([5, 5, 5]) == true
-assert stable?([5, 5, 6]) == false
-assert stable?([5, 6, 5]) == false
-assert stable?([5]) == false  # 3つ未満は false
-```
-
-<details>
-<summary>解答</summary>
-
-```elixir
-def stable?(values) when length(values) < 3, do: false
-
-def stable?(values) do
-  values |> Enum.uniq() |> length() == 1
-end
-```
-
-</details>
+# Part IV: IO とストリーム処理
+
+本章では、関数型プログラミングにおける副作用の扱い方を学びます。Elixir の無名関数を使って副作用を遅延実行し、Stream モジュールで無限のデータを効率的に扱う方法を習得します。
+
+---
+
+## 第8章: IO パターンとプロセス
+
+### 8.1 副作用の問題
+
+純粋関数は副作用を持ちません。しかし、実際のプログラムには副作用が必要です:
+
+- ファイルの読み書き
+- ネットワーク通信
+- データベースアクセス
+- 乱数生成
+- 現在時刻の取得
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "副作用の問題" {
+  rectangle "副作用を持つ関数" as impure {
+    card "テストが困難"
+    card "予測不可能"
+    card "参照透過性がない"
+  }
+
+  rectangle "純粋関数" as pure {
+    card "テストが容易"
+    card "予測可能"
+    card "参照透過性がある"
+  }
+}
+
+note bottom
+  どうすれば副作用を
+  純粋関数のように扱えるか？
+end note
+
+@enduml
+```
+
+### 8.2 Elixir における IO パターン
+
+Scala の `IO` モナドに相当する概念を、Elixir では**無名関数**を使って表現します。
+
+- `fn -> expr end` は「実行すると結果を返す副作用のある計算」
+- 関数を作成しただけでは副作用は発生しない
+- 関数を呼び出すことで実際に実行される
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "遅延実行パターンの仕組み" {
+  card "delay(fn -> 副作用 end)" as create
+  card "関数値" as io
+  card "run(io)" as run
+  card "副作用が実行される" as effect
+
+  create --> io : 記述を作成
+  io --> run : 実行を指示
+  run --> effect : 実際に実行
+}
+
+note bottom of io
+  この時点では
+  副作用は発生しない
+end note
+
+@enduml
+```
+
+### 8.3 サイコロを振る例
+
+**ソースファイル**: `app/elixir/lib/ch08/io_and_processes.ex`
+
+#### 不純な関数（副作用あり）
+
+```elixir
+def cast_the_die_impure do
+  :rand.uniform(6)
+end
+
+# 呼び出すたびに異なる値が返る
+IO.inspect(cast_the_die_impure())  # 3
+IO.inspect(cast_the_die_impure())  # 5
+IO.inspect(cast_the_die_impure())  # 1
+```
+
+#### 遅延実行パターン
+
+```elixir
+@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
+
+# 関数を作成（この時点では実行されない）
+die_cast = cast_the_die()
+IO.inspect(die_cast)  # #Function<...> - まだ実行されていない
+
+# 実際に実行
+IO.inspect(run(die_cast))  # 4
+```
+
+### 8.4 IO の作成方法
+
+| 関数 | 用途 | 例 |
+|------|------|-----|
+| `delay(f)` | 副作用のある式をラップ | `delay(fn -> IO.puts("hello") end)` |
+| `pure(value)` | 既存の値をラップ（副作用なし） | `pure(42)` |
+
+```elixir
+# delay: 副作用を遅延実行
+delayed_print = delay(fn -> IO.puts("Hello") end)
+# IO.puts はまだ実行されていない
+
+# pure: 既存の値をラップ
+pure_value = pure(42)
+# 副作用なし、即座に 42 が確定
+```
+
+### 8.5 IO の合成
+
+IO 値は `flat_map` でチェーンできます。Scala の `for` 内包表記に相当します。
+
+```elixir
+@spec flat_map((-> any()), (any() -> (-> any()))) :: (-> any())
+def flat_map(io, f) do
+  fn ->
+    result = run(io)
+    run(f.(result))
+  end
+end
+
+def cast_the_die_twice do
+  flat_map(cast_the_die(), fn first ->
+    map(cast_the_die(), fn second ->
+      first + second
+    end)
+  end)
+end
+
+# まだ実行されていない
+program = cast_the_die_twice()
+
+# 実行
+result = run(program)  # 2〜12 の値
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "IO の合成" {
+  card "cast_the_die()" as cast1
+  card "cast_the_die()" as cast2
+  card "first + second" as combine
+
+  cast1 --> combine : flat_map
+  cast2 --> combine : map
+}
+
+note bottom
+  flat_map でチェーンして
+  順序付けて合成
+end note
+
+@enduml
+```
+
+### 8.6 ミーティングスケジューリングの例
+
+より実践的な例として、ミーティングのスケジューリングを見てみましょう。
+
+```elixir
+defmodule MeetingTime do
+  defstruct [:start_hour, :end_hour]
+end
+
+# 副作用のある API 呼び出しを遅延実行
+def calendar_entries(name) do
+  delay(fn ->
+    # モックデータ（実際には API 呼び出し）
+    case name do
+      "Alice" -> [%MeetingTime{start_hour: 9, end_hour: 10}, ...]
+      "Bob" -> [%MeetingTime{start_hour: 10, end_hour: 11}, ...]
+      _ -> []
+    end
+  end)
+end
+```
+
+#### 予定の取得
+
+```elixir
+def scheduled_meetings(person1, person2) do
+  flat_map(calendar_entries(person1), fn entries1 ->
+    map(calendar_entries(person2), fn entries2 ->
+      entries1 ++ entries2
+    end)
+  end)
+end
+
+# 使用例
+io = scheduled_meetings("Alice", "Bob")
+meetings = run(io)  # 4件の予定
+```
+
+#### 空き時間の計算（純粋関数）
+
+```elixir
+def possible_meetings(existing_meetings, start_hour, end_hour, length_hours) do
+  slots =
+    start_hour..(end_hour - length_hours)
+    |> Enum.map(fn start ->
+      %MeetingTime{start_hour: start, end_hour: start + length_hours}
+    end)
+
+  Enum.filter(slots, fn slot ->
+    Enum.all?(existing_meetings, fn meeting ->
+      not meetings_overlap?(meeting, slot)
+    end)
+  end)
+end
+
+# ミーティングが重なるかチェック
+def meetings_overlap?(m1, m2) do
+  m1.start_hour < m2.end_hour && m2.start_hour < m1.end_hour
+end
+```
+
+### 8.7 or_else によるエラーハンドリング
+
+`or_else` 関数で、失敗時のフォールバックを指定できます。
+
+```elixir
+def or_else(io, fallback) do
+  fn ->
+    try do
+      run(io)
+    rescue
+      _ -> run(fallback)
+    end
+  end
+end
+
+success = pure(42)
+fallback = pure(0)
+run(or_else(success, fallback))  # 42
+
+failing = fn -> raise "error" end
+run(or_else(failing, fallback))  # 0
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "or_else の動作" {
+  card "メインの IO" as main
+  card "フォールバック IO" as fallback
+  card "結果" as result
+
+  main --> result : 成功時
+  main --> fallback : 失敗時
+  fallback --> result
+}
+
+@enduml
+```
+
+#### リトライ戦略
+
+```elixir
+def retry(io, max_retries) do
+  fn ->
+    do_retry(io, max_retries, nil)
+  end
+end
+
+defp do_retry(_io, 0, last_error), do: raise(last_error || "Max retries exceeded")
+
+defp do_retry(io, retries_left, _last_error) do
+  try do
+    run(io)
+  rescue
+    e -> do_retry(io, retries_left - 1, e)
+  end
+end
+
+# 使用例：API 呼び出しを5回までリトライ
+result = retry(calendar_entries("Alice"), 5)
+```
+
+### 8.8 sequence による IO のリスト処理
+
+`[IO]` を `IO[List]` に変換するには `sequence` を使います。
+
+```elixir
+def sequence(ios) do
+  fn -> Enum.map(ios, &run/1) end
+end
+
+ios = [pure(1), pure(2), pure(3)]
+combined = sequence(ios)
+run(combined)  # [1, 2, 3]
+```
+
+#### 複数人の予定を取得
+
+```elixir
+def scheduled_meetings_for(attendees) do
+  attendees
+  |> Enum.map(&calendar_entries/1)
+  |> sequence()
+  |> map(&List.flatten/1)
+end
+
+# 使用例
+io = scheduled_meetings_for(["Alice", "Bob"])
+meetings = run(io)  # 4件の予定
+```
+
+### 8.9 Agent による状態管理
+
+Elixir では `Agent` を使って状態を安全に管理できます。
+
+```elixir
+def create_counter(initial_value) do
+  Agent.start_link(fn -> initial_value end)
+end
+
+def get_count(counter) do
+  Agent.get(counter, & &1)
+end
+
+def increment(counter) do
+  Agent.update(counter, &(&1 + 1))
+end
+
+# 使用例
+{:ok, counter} = create_counter(0)
+get_count(counter)  # 0
+increment(counter)
+get_count(counter)  # 1
+```
+
+### 8.10 Task による非同期処理
+
+`Task` を使って非同期処理を実行できます。
+
+```elixir
+def async_calendar_entries(name) do
+  Task.async(fn -> run(calendar_entries(name)) end)
+end
+
+def parallel_calendar_entries(names) do
+  names
+  |> Enum.map(&async_calendar_entries/1)
+  |> Task.await_many()
+  |> List.flatten()
+end
+
+# 使用例：並行でカレンダーを取得
+entries = parallel_calendar_entries(["Alice", "Bob"])  # 4件
+```
+
+---
+
+## 第9章: ストリーム処理
+
+### 9.1 ストリームとは
+
+**ストリーム**は、要素の（潜在的に無限の）シーケンスを遅延評価で表します。Elixir の `Stream` モジュールを使用します。
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "List vs Stream" {
+  rectangle "List" as list {
+    card "全要素がメモリに存在"
+    card "有限"
+    card "即座に評価"
+  }
+
+  rectangle "Stream" as stream {
+    card "必要な時に要素を生成"
+    card "無限も可能"
+    card "遅延評価"
+  }
+}
+
+@enduml
+```
+
+### 9.2 基本的なストリーム操作
+
+**ソースファイル**: `app/elixir/lib/ch09/streams.ex`
+
+```elixir
+# 有限ストリーム
+def finite_stream(list), do: Stream.map(list, & &1)
+
+stream = finite_stream([1, 2, 3])
+Enum.to_list(stream)  # [1, 2, 3]
+
+# フィルタリング
+def filter_stream(stream, predicate), do: Stream.filter(stream, predicate)
+
+odd_numbers = filter_stream([1, 2, 3, 4, 5], &(rem(&1, 2) != 0))
+Enum.to_list(odd_numbers)  # [1, 3, 5]
+```
+
+### 9.3 無限ストリーム
+
+```elixir
+# 無限に繰り返し
+def repeat(list), do: Stream.cycle(list)
+
+infinite = repeat([1, 2, 3])
+Enum.take(infinite, 8)  # [1, 2, 3, 1, 2, 3, 1, 2]
+
+# 生成関数を使用
+def generate(f), do: Stream.repeatedly(f)
+
+stream = generate(fn -> :rand.uniform(6) end)
+Enum.take(stream, 5)  # [4, 2, 6, 1, 3]
+
+# カウントアップ
+def count_from(start), do: Stream.iterate(start, &(&1 + 1))
+
+stream = count_from(1)
+Enum.take(stream, 5)  # [1, 2, 3, 4, 5]
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "無限ストリーム" {
+  card "Stream.cycle([1, 2, 3])" as stream
+  card "1, 2, 3, 1, 2, 3, 1, 2, 3, ..." as infinite
+  card "Enum.take(8)" as take
+  card "[1, 2, 3, 1, 2, 3, 1, 2]" as result
+
+  stream --> infinite
+  infinite --> take
+  take --> result
+}
+
+note bottom
+  無限のストリームから
+  必要な分だけ取得
+end note
+
+@enduml
+```
+
+### 9.4 サイコロストリーム
+
+```elixir
+def die_casts do
+  Stream.repeatedly(fn -> :rand.uniform(6) end)
+end
+
+# 最初の3回を取得
+die_casts() |> Enum.take(3)  # [4, 2, 6]
+
+# 6 が出るまで振り続ける
+def roll_until(target) do
+  die_casts()
+  |> Stream.take_while(fn x -> x != target end)
+  |> Enum.to_list()
+  |> Kernel.++([target])
+end
+
+roll_until(6)  # [2, 4, 1, 3, 6]
+
+# 指定回数振って合計
+def roll_and_sum(n) do
+  die_casts()
+  |> Enum.take(n)
+  |> Enum.sum()
+end
+
+roll_and_sum(3)  # 3〜18 の値
+```
+
+### 9.5 ストリームの主要操作
+
+| 操作 | 説明 | 例 |
+|------|------|-----|
+| `Stream.take(n)` | 最初の n 要素を取得 | `stream \|> Stream.take(3)` |
+| `Stream.filter(p)` | 条件を満たす要素のみ | `stream \|> Stream.filter(&(&1 > 0))` |
+| `Stream.map(f)` | 各要素を変換 | `stream \|> Stream.map(&(&1 * 2))` |
+| `Stream.concat(s)` | 別のストリームを結合 | `Stream.concat(s1, s2)` |
+| `Stream.cycle(list)` | 無限に繰り返し | `Stream.cycle([1, 2, 3])` |
+| `Stream.chunk_every(n, step)` | スライディングウィンドウ | `stream \|> Stream.chunk_every(3, 1)` |
+
+### 9.6 通貨交換レートの例
+
+為替レートを監視して、上昇トレンドを検出する例です。
+
+#### トレンド判定（純粋関数）
+
+```elixir
+def trending?(rates) when length(rates) <= 1, do: false
+
+def trending?(rates) do
+  rates
+  |> Enum.zip(Enum.drop(rates, 1))
+  |> Enum.all?(fn {prev, curr} -> curr > prev end)
+end
+
+trending?([0.81, 0.82, 0.83])  # true (上昇トレンド)
+trending?([0.81, 0.84, 0.83])  # false
+
+def declining?(rates) when length(rates) <= 1, do: false
+
+def declining?(rates) do
+  rates
+  |> Enum.zip(Enum.drop(rates, 1))
+  |> Enum.all?(fn {prev, curr} -> curr < prev end)
+end
+
+declining?([0.83, 0.82, 0.81])  # true (下降トレンド)
+
+def stable?(values) when length(values) < 3, do: false
+
+def stable?(values) do
+  values |> Enum.uniq() |> length() == 1
+end
+
+stable?([5, 5, 5])  # true (安定)
+```
+
+#### レートのストリーム
+
+```elixir
+def exchange_rate(from, to) do
+  # モックの為替レート（実際には API を呼び出す）
+  base_rates = %{
+    {:usd, :eur} => 0.85,
+    {:usd, :gbp} => 0.73,
+    # ...
+  }
+
+  base_rate = Map.get(base_rates, {from, to}, 1.0)
+  variation = (:rand.uniform() - 0.5) * 0.02
+  base_rate * (1 + variation)
+end
+
+def rate_stream(from, to) do
+  Stream.repeatedly(fn -> exchange_rate(from, to) end)
+end
+
+# 使用例
+rate_stream(:usd, :eur) |> Enum.take(3)
+# [0.8493, 0.8521, 0.8478]
+```
+
+### 9.7 スライディングウィンドウ
+
+`Stream.chunk_every/4` で連続する要素をグループ化できます。
+
+```elixir
+def sliding(stream, size) do
+  Stream.chunk_every(stream, size, 1, :discard)
+end
+
+sliding([1, 2, 3, 4, 5], 3) |> Enum.to_list()
+# [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "sliding(3) の動作" {
+  card "[1, 2, 3, 4, 5]" as input
+  card "[1, 2, 3]" as w1
+  card "[2, 3, 4]" as w2
+  card "[3, 4, 5]" as w3
+
+  input --> w1
+  input --> w2
+  input --> w3
+}
+
+@enduml
+```
+
+#### トレンドを検出して交換
+
+```elixir
+def exchange_if_trending(amount, from, to, window_size, max_attempts) do
+  result =
+    rate_stream(from, to)
+    |> sliding(window_size)
+    |> Stream.filter(&trending?/1)     # 上昇トレンドを検出
+    |> Stream.map(&List.last/1)        # 最新のレートを取得
+    |> Stream.take(1)
+    |> Enum.take(max_attempts)
+    |> List.first()
+
+  case result do
+    nil -> {:error, "No trending pattern found"}
+    rate -> {:ok, rate * amount}
+  end
+end
+
+# 使用例
+exchange_if_trending(100.0, :usd, :eur, 3, 1000)
+# {:ok, 85.23}
+```
+
+### 9.8 ストリームの結合
+
+2つのストリームを `Stream.zip` で結合できます。
+
+```elixir
+def zip_streams(stream1, stream2) do
+  Stream.zip(stream1, stream2)
+end
+
+zip_streams([1, 2, 3], ["a", "b", "c"]) |> Enum.to_list()
+# [{1, "a"}, {2, "b"}, {3, "c"}]
+
+# 左側の値だけ返す
+def zip_left(stream1, stream2) do
+  Stream.zip(stream1, stream2)
+  |> Stream.map(fn {left, _right} -> left end)
+end
+
+# インターバル付きで処理
+def with_interval(stream, interval_ms) do
+  Stream.map(stream, fn item ->
+    Process.sleep(interval_ms)
+    item
+  end)
+end
+
+# レートを1秒間隔で取得
+rate_stream(:usd, :eur)
+|> with_interval(1000)
+|> Enum.take(5)
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "zip_left の動作" {
+  card "rates: [0.81, 0.82, 0.83, ...]" as rates
+  card "ticks: [:tick, :tick, :tick, ...]" as ticks
+  card "zip_left" as zip
+  card "[0.81, 0.82, 0.83, ...] (1秒間隔)" as result
+
+  rates --> zip
+  ticks --> zip
+  zip --> result
+}
+
+note bottom
+  左側の値を返しつつ
+  右側のペースで進む
+end note
+
+@enduml
+```
+
+### 9.9 集計操作
+
+```elixir
+# 合計
+def sum_stream(stream), do: Enum.sum(stream)
+
+sum_stream([1, 2, 3, 4, 5])  # 15
+
+# 平均
+def average_stream(stream) do
+  {sum, count} =
+    Enum.reduce(stream, {0, 0}, fn x, {sum, count} ->
+      {sum + x, count + 1}
+    end)
+
+  if count == 0, do: 0.0, else: sum / count
+end
+
+average_stream([1, 2, 3, 4, 5])  # 3.0
+
+# 移動平均
+def moving_average(stream, window_size) do
+  stream
+  |> sliding(window_size)
+  |> Stream.map(&average_stream/1)
+end
+
+moving_average([1, 2, 3, 4, 5], 3) |> Enum.to_list()
+# [2.0, 3.0, 4.0]
+```
+
+### 9.10 unfold によるストリーム生成
+
+`Stream.unfold/2` で状態を持つストリームを生成できます。
+
+```elixir
+# フィボナッチ数列
+def fibonacci do
+  Stream.unfold({0, 1}, fn {a, b} ->
+    {a, {b, a + b}}
+  end)
+end
+
+fibonacci() |> Enum.take(10)
+# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+# 等比数列
+def geometric_series(start, ratio) do
+  Stream.unfold(start, fn current ->
+    {current, current * ratio}
+  end)
+end
+
+geometric_series(1, 2) |> Enum.take(5)
+# [1, 2, 4, 8, 16]
+
+# 等差数列
+def arithmetic_series(start, diff) do
+  Stream.unfold(start, fn current ->
+    {current, current + diff}
+  end)
+end
+
+arithmetic_series(1, 3) |> Enum.take(5)
+# [1, 4, 7, 10, 13]
+```
+
+---
+
+## まとめ
+
+### Part IV で学んだこと
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "Part IV: IO とストリーム処理" {
+  rectangle "第8章" as ch8 {
+    card "遅延実行パターン"
+    card "delay / run"
+    card "flat_map / map"
+    card "or_else / retry"
+    card "sequence"
+    card "Agent / Task"
+  }
+
+  rectangle "第9章" as ch9 {
+    card "Elixir Stream"
+    card "無限ストリーム"
+    card "cycle / take"
+    card "sliding"
+    card "zip / zip_left"
+    card "unfold"
+  }
+}
+
+ch8 --> ch9
+
+@enduml
+```
+
+### Scala との対応
+
+| Scala | Elixir |
+|-------|--------|
+| `IO[A]` | `(-> any())` (無名関数) |
+| `IO.delay(expr)` | `delay(fn -> expr end)` |
+| `IO.pure(value)` | `pure(value)` |
+| `unsafeRunSync()` | `run(io)` |
+| `flatMap` | `flat_map/2` |
+| `orElse` | `or_else/2` |
+| `sequence` | `sequence/1` |
+| `fs2.Stream` | `Stream` モジュール |
+| `Stream.eval` | `Stream.repeatedly` |
+| `sliding(n)` | `Stream.chunk_every(n, 1, :discard)` |
+| `zipLeft` | `zip_left/2` |
+
+### キーポイント
+
+1. **遅延実行パターン**: 副作用を「記述」として扱い、実行を遅延させる
+2. **delay/run**: 副作用のある式を遅延実行
+3. **or_else**: 失敗時のフォールバックを指定
+4. **sequence**: `[IO]` → `IO[List]`
+5. **Stream**: 潜在的に無限のシーケンスを遅延評価で処理
+6. **sliding**: 連続する要素をグループ化してパターンを検出
+7. **unfold**: 状態を持つストリームを生成
+
+### Elixir の特徴
+
+- **Agent**: プロセスベースの状態管理
+- **Task**: 簡単な非同期処理
+- **Stream**: 組み込みの遅延評価ストリーム
+
+### 次のステップ
+
+Part V では、以下のトピックを学びます:
+
+- 並行・並列処理
+- GenServer による状態管理
+- Supervisor による耐障害性
+
+---
+
+## 演習問題
+
+### 問題 1: IO の基本
+
+以下の関数を実装してください。
+
+```elixir
+def print_and_return(message) do
+  # メッセージを出力して、そのメッセージを返す IO を作成
+  ???
+end
+
+# 期待される動作
+# io = print_and_return("Hello")
+# run(io) は "Hello" をコンソールに出力し、"Hello" を返す
+```
+
+<details>
+<summary>解答</summary>
+
+```elixir
+def print_and_return(message) do
+  delay(fn ->
+    IO.puts(message)
+    message
+  end)
+end
+```
+
+</details>
+
+### 問題 2: IO の合成
+
+以下の関数を実装してください。2つの IO を順番に実行し、結果を結合します。
+
+```elixir
+def combine_io(io1, io2, f) do
+  # io1 と io2 を実行し、結果を f で結合
+  ???
+end
+
+# 期待される動作
+# io = combine_io(pure(1), pure(2), &(&1 + &2))
+# run(io)  # 3
+```
+
+<details>
+<summary>解答</summary>
+
+```elixir
+def combine_io(io1, io2, f) do
+  flat_map(io1, fn a ->
+    map(io2, fn b ->
+      f.(a, b)
+    end)
+  end)
+end
+```
+
+</details>
+
+### 問題 3: リトライ
+
+以下の関数を実装してください。指定回数リトライし、全部失敗したらデフォルト値を返します。
+
+```elixir
+def retry_with_default(io, max_retries, default) do
+  ???
+end
+```
+
+<details>
+<summary>解答</summary>
+
+```elixir
+def retry_with_default(io, max_retries, default) do
+  fn ->
+    try do
+      run(retry(io, max_retries))
+    rescue
+      _ -> default
+    end
+  end
+end
+```
+
+</details>
+
+### 問題 4: ストリーム操作
+
+以下のストリームを作成してください。
+
+```elixir
+# 1. 1から10までの偶数のストリーム
+evens = ???
+
+# 2. 無限に交互に true/false を返すストリーム
+alternating = ???
+
+# 3. 最初の5つの要素の合計を計算
+sum = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |> Stream.take(5) |> ???
+```
+
+<details>
+<summary>解答</summary>
+
+```elixir
+# 1. 1から10までの偶数
+evens = 1..10 |> Stream.filter(&(rem(&1, 2) == 0))
+# または
+evens = Stream.iterate(2, &(&1 + 2)) |> Stream.take_while(&(&1 <= 10))
+
+# 2. 無限に交互に true/false
+alternating = Stream.cycle([true, false])
+
+# 3. 最初の5つの要素の合計
+sum = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |> Stream.take(5) |> Enum.sum()  # 15
+```
+
+</details>
+
+### 問題 5: トレンド検出
+
+以下の関数を実装してください。直近3つの値が全て同じかどうかを判定します。
+
+```elixir
+def stable?(values) do
+  ???
+end
+
+# 期待される動作
+assert stable?([5, 5, 5]) == true
+assert stable?([5, 5, 6]) == false
+assert stable?([5, 6, 5]) == false
+assert stable?([5]) == false  # 3つ未満は false
+```
+
+<details>
+<summary>解答</summary>
+
+```elixir
+def stable?(values) when length(values) < 3, do: false
+
+def stable?(values) do
+  values |> Enum.uniq() |> length() == 1
+end
+```
+
+</details>