@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/elixir/08-error-handling-strategies.md

@@ -0,0 +1,168 @@
+# Chapter 08: エラーハンドリング戦略
+
+Elixir における関数型エラーハンドリングパターンを学びます。
+
+## 概要
+
+Elixir では、例外よりも戻り値による明示的なエラー処理が推奨されます。このチャプターでは、Result 型、Validated パターン、エラー復旧戦略を紹介します。
+
+## 主なトピック
+
+1. **Result 型**
+2. **Either パターン**
+3. **Validated パターン（エラー蓄積）**
+4. **エラー復旧パターン**
+5. **エラードメインモデリング**
+
+## Result 型
+
+成功と失敗を明示的に表現します。
+
+```elixir
+defmodule Result do
+  @type t(a, e) :: {:ok, a} | {:error, e}
+
+  def ok(value), do: {:ok, value}
+  def error(reason), do: {:error, reason}
+
+  def map({:ok, value}, f), do: {:ok, f.(value)}
+  def map({:error, _} = err, _f), do: err
+
+  def flat_map({:ok, value}, f), do: f.(value)
+  def flat_map({:error, _} = err, _f), do: err
+
+  def unwrap_or({:ok, value}, _default), do: value
+  def unwrap_or({:error, _}, default), do: default
+end
+```
+
+### 使用例
+
+```elixir
+def divide(a, b) when b != 0, do: {:ok, a / b}
+def divide(_, 0), do: {:error, "Division by zero"}
+
+# チェイン
+{:ok, 10}
+|> Result.flat_map(&divide(&1, 2))
+|> Result.flat_map(&divide(&1, 0))
+# => {:error, "Division by zero"}
+```
+
+## Validated パターン
+
+すべてのエラーを蓄積します。
+
+```elixir
+defmodule Validated do
+  @type t(a, e) :: {:valid, a} | {:invalid, [e]}
+
+  def valid(value), do: {:valid, value}
+  def invalid(error), do: {:invalid, [error]}
+
+  def combine({:valid, a}, {:valid, b}, f), do: {:valid, f.(a, b)}
+  def combine({:invalid, e1}, {:invalid, e2}, _f), do: {:invalid, e1 ++ e2}
+  def combine({:valid, _}, {:invalid, errors}, _f), do: {:invalid, errors}
+  def combine({:invalid, errors}, {:valid, _}, _f), do: {:invalid, errors}
+end
+```
+
+### バリデーション例
+
+```elixir
+def validate_user(username, email, age) do
+  username_result = validate_username(username)
+  email_result = validate_email(email)
+  age_result = validate_age(age)
+
+  Validated.sequence([username_result, email_result, age_result])
+  |> Validated.map(fn [u, e, a] -> %{username: u, email: e, age: a} end)
+end
+
+# 全てのエラーを収集
+validate_user("", "invalid", 10)
+# => {:invalid, [{:required_field, "username"}, {:invalid_format, "email", ...}, {:out_of_range, "age", 18, 120}]}
+```
+
+## エラードメインモデリング
+
+ドメイン固有のエラー型を定義します。
+
+```elixir
+defmodule Errors do
+  @type validation_error ::
+    {:required_field, String.t()}
+    | {:invalid_format, String.t(), String.t()}
+    | {:out_of_range, String.t(), number(), number()}
+
+  @type business_error ::
+    {:insufficient_funds, number(), number()}
+    | {:item_not_found, String.t()}
+    | {:duplicate_entry, String.t()}
+
+  def format({:required_field, field}) do
+    "フィールド '#{field}' は必須です"
+  end
+  def format({:insufficient_funds, required, available}) do
+    "残高不足: 必要額 #{required}、残高 #{available}"
+  end
+end
+```
+
+## エラー復旧パターン
+
+### リトライ
+
+```elixir
+def retry(operation, max_attempts, should_retry) do
+  result = operation.()
+  cond do
+    Result.ok?(result) -> result
+    attempt >= max_attempts -> result
+    should_retry.(result) -> retry(operation, max_attempts, should_retry, attempt + 1)
+    true -> result
+  end
+end
+```
+
+### フォールバック
+
+```elixir
+def fallback_chain([]), do: {:error, "all fallbacks failed"}
+def fallback_chain([operation | rest]) do
+  case operation.() do
+    {:ok, _} = ok -> ok
+    {:error, _} -> fallback_chain(rest)
+  end
+end
+```
+
+## パイプライン with エラー
+
+```elixir
+defmodule Pipeline do
+  def pipe(initial, functions) do
+    Enum.reduce(functions, initial, fn f, acc ->
+      Result.flat_map(acc, f)
+    end)
+  end
+end
+
+Pipeline.pipe({:ok, 10}, [
+  &({:ok, &1 * 2}),
+  &({:ok, &1 + 5})
+])
+# => {:ok, 25}
+```
+
+## まとめ
+
+- **Result 型**で成功/失敗を明示的に表現
+- **Validated パターン**で全てのエラーを蓄積
+- **エラードメインモデリング**で型安全なエラー処理
+- **リトライ/フォールバック**で復旧可能なエラーを処理
+
+## 関連リソース
+
+- [Railway Oriented Programming](https://fsharpforfunandprofit.com/rop/)
+- [Elixir with Pattern](https://hexdocs.pm/elixir/Kernel.SpecialForms.html#with/1)

package/lib/assets/docs/article/functional-desgin-ppp/elixir/09-io-and-external-systems.md

@@ -0,0 +1,254 @@
+# Chapter 09: I/O と外部システム
+
+Elixir における I/O 操作と外部システムとの連携を関数型に扱う方法を学びます。
+
+## 概要
+
+I/O 操作や外部システムとの連携は副作用を伴います。このチャプターでは、これらを抽象化してテスト可能にするパターンを紹介します。
+
+## 主なトピック
+
+1. **I/O の抽象化**
+2. **ファイルシステム操作**
+3. **リポジトリパターン**
+4. **HTTP クライアントの抽象化**
+5. **設定管理**
+6. **トランザクション風操作**
+
+## コンソール I/O の抽象化
+
+```elixir
+defmodule IO.Console do
+  @type console :: %{
+    read: (() -> String.t()),
+    write: (String.t() -> :ok)
+  }
+
+  def standard do
+    %{
+      read: fn -> IO.gets("") |> String.trim() end,
+      write: fn msg -> IO.puts(msg); :ok end
+    }
+  end
+
+  def test_console(inputs) do
+    {:ok, input_agent} = Agent.start_link(fn -> inputs end)
+    {:ok, output_agent} = Agent.start_link(fn -> [] end)
+
+    console = %{
+      read: fn ->
+        Agent.get_and_update(input_agent, fn
+          [head | tail] -> {head, tail}
+          [] -> {"", []}
+        end)
+      end,
+      write: fn msg ->
+        Agent.update(output_agent, fn outputs -> outputs ++ [msg] end)
+        :ok
+      end
+    }
+
+    get_output = fn -> Agent.get(output_agent, & &1) end
+    {console, get_output}
+  end
+end
+```
+
+## ファイルシステムの抽象化
+
+```elixir
+defmodule IO.FileSystem do
+  def in_memory(initial_files \\ %{}) do
+    {:ok, agent} = Agent.start_link(fn -> initial_files end)
+
+    fs = %{
+      read: fn path ->
+        case Agent.get(agent, &Map.get(&1, path)) do
+          nil -> {:error, :enoent}
+          content -> {:ok, content}
+        end
+      end,
+      write: fn path, content ->
+        Agent.update(agent, &Map.put(&1, path, content))
+        :ok
+      end,
+      exists?: fn path -> Agent.get(agent, &Map.has_key?(&1, path)) end,
+      delete: fn path -> Agent.update(agent, &Map.delete(&1, path)); :ok end
+    }
+
+    get_state = fn -> Agent.get(agent, & &1) end
+    {fs, get_state}
+  end
+end
+```
+
+## リポジトリパターン
+
+```elixir
+defmodule Repository do
+  def in_memory do
+    {:ok, agent} = Agent.start_link(fn -> %{} end)
+
+    %{
+      find: fn id ->
+        case Agent.get(agent, &Map.get(&1, id)) do
+          nil -> {:error, :not_found}
+          entity -> {:ok, entity}
+        end
+      end,
+      find_all: fn -> Agent.get(agent, &Map.values(&1)) end,
+      save: fn entity ->
+        Agent.update(agent, &Map.put(&1, entity.id, entity))
+        {:ok, entity}
+      end,
+      delete: fn id ->
+        Agent.update(agent, &Map.delete(&1, id))
+        :ok
+      end,
+      exists?: fn id -> Agent.get(agent, &Map.has_key?(&1, id)) end
+    }
+  end
+
+  def find_by(repo, predicate) do
+    repo.find_all.() |> Enum.filter(predicate)
+  end
+end
+```
+
+## HTTP クライアントの抽象化
+
+```elixir
+defmodule Http do
+  def test_client(responses) do
+    make_request = fn url ->
+      case Map.get(responses, url) do
+        nil -> {:error, :not_found}
+        response -> {:ok, response}
+      end
+    end
+
+    %{
+      get: make_request,
+      post: fn url, _body -> make_request.(url) end,
+      put: fn url, _body -> make_request.(url) end,
+      delete: make_request
+    }
+  end
+end
+
+# 使用例
+responses = %{
+  "https://api.example.com/users/1" => %{
+    status: 200,
+    body: ~s({"id": "1", "name": "Alice"})
+  }
+}
+
+client = Http.test_client(responses)
+{:ok, response} = client.get.("https://api.example.com/users/1")
+```
+
+## 設定管理
+
+```elixir
+defmodule Config do
+  def from_map(config) do
+    %{
+      get: &Map.get(config, &1),
+      get_all: fn -> config end
+    }
+  end
+
+  def require(source, key) do
+    case source.get.(key) do
+      nil -> {:error, {:missing_config, key}}
+      value -> {:ok, value}
+    end
+  end
+
+  def get_or_default(source, key, default) do
+    source.get.(key) || default
+  end
+
+  def get_integer(source, key, default) do
+    case source.get.(key) do
+      nil -> default
+      value ->
+        case Integer.parse(value) do
+          {int, ""} -> int
+          _ -> default
+        end
+    end
+  end
+end
+```
+
+## トランザクション風操作
+
+```elixir
+defmodule Transaction do
+  def execute(operations) do
+    do_execute(operations, [], [])
+  end
+
+  defp do_execute([], results, _rollbacks), do: {:ok, Enum.reverse(results)}
+  defp do_execute([{operation, rollback} | rest], results, rollbacks) do
+    case operation.() do
+      {:ok, result} ->
+        do_execute(rest, [result | results], [rollback | rollbacks])
+      {:error, reason} ->
+        Enum.each(rollbacks, fn rb -> rb.() end)
+        {:error, reason}
+    end
+  end
+
+  def with_resource(acquire, release, use) do
+    case acquire.() do
+      {:ok, resource} ->
+        try do
+          use.(resource)
+        after
+          release.(resource)
+        end
+      {:error, _} = error -> error
+    end
+  end
+end
+```
+
+## サービス層の例
+
+```elixir
+defmodule UserService do
+  def create_user(repo, params, id_generator, time_provider) do
+    with :ok <- validate_name(params.name),
+         :ok <- validate_email(params.email),
+         false <- email_exists?(repo, params.email) do
+      user = %{
+        id: id_generator.(),
+        name: params.name,
+        email: params.email,
+        created_at: time_provider.()
+      }
+      repo.save.(user)
+      {:ok, user}
+    else
+      {:error, _} = error -> error
+      true -> {:error, :email_already_exists}
+    end
+  end
+end
+```
+
+## まとめ
+
+- **I/O の抽象化**でテスト可能な設計
+- **リポジトリパターン**でデータ永続化を抽象化
+- **HTTP クライアントの抽象化**で外部 API をモック
+- **設定管理**で環境依存を分離
+- **トランザクション風操作**でリソース管理を安全に
+
+## 関連リソース
+
+- [Hexagonal Architecture](https://alistair.cockburn.us/hexagonal-architecture/)
+- [Ports and Adapters](https://www.youtube.com/watch?v=th4AgBcrEHA)

package/lib/assets/docs/article/functional-desgin-ppp/elixir/10-concurrency-patterns.md

@@ -0,0 +1,269 @@
+# Chapter 10: 並行処理パターン
+
+Elixir における並行処理パターンを学びます。アクターモデルと関数型プログラミングを組み合わせた安全な並行処理を実装します。
+
+## 概要
+
+Elixir は Erlang VM 上で動作し、軽量プロセスによる並行処理をサポートします。このチャプターでは、プロセス、Agent、GenServer、Task を使った並行処理パターンを紹介します。
+
+## 主なトピック
+
+1. **プロセスとメッセージパッシング**
+2. **Agent（状態管理）**
+3. **GenServer（汎用サーバー）**
+4. **Task（非同期処理）**
+5. **並列処理パターン**
+6. **同期パターン**
+
+## 基本的なプロセス
+
+```elixir
+defmodule BasicProcess do
+  def start_echo do
+    spawn(fn -> echo_loop() end)
+  end
+
+  defp echo_loop do
+    receive do
+      {:echo, from, message} ->
+        send(from, {:echoed, message})
+        echo_loop()
+      :stop -> :ok
+    end
+  end
+end
+
+# 使用例
+pid = BasicProcess.start_echo()
+send(pid, {:echo, self(), "hello"})
+receive do
+  {:echoed, msg} -> msg  # => "hello"
+end
+```
+
+## Agent（状態管理）
+
+```elixir
+defmodule Counter do
+  def start(initial_value \\ 0) do
+    Agent.start_link(fn -> initial_value end)
+  end
+
+  def get(counter), do: Agent.get(counter, & &1)
+  def increment(counter), do: Agent.update(counter, &(&1 + 1))
+  def decrement(counter), do: Agent.update(counter, &(&1 - 1))
+  def add(counter, value), do: Agent.update(counter, &(&1 + value))
+  def reset(counter), do: Agent.update(counter, fn _ -> 0 end)
+end
+
+# 並行アクセスでも安全
+{:ok, counter} = Counter.start(0)
+tasks = for _ <- 1..100 do
+  Task.async(fn -> Counter.increment(counter) end)
+end
+Enum.each(tasks, &Task.await/1)
+Counter.get(counter)  # => 100
+```
+
+## GenServer
+
+```elixir
+defmodule BankAccount do
+  use GenServer
+
+  # Client API
+  def open(account_id, initial_balance \\ 0) do
+    GenServer.start_link(__MODULE__, %{id: account_id, balance: initial_balance})
+  end
+
+  def balance(account), do: GenServer.call(account, :balance)
+  def deposit(account, amount), do: GenServer.call(account, {:deposit, amount})
+  def withdraw(account, amount), do: GenServer.call(account, {:withdraw, amount})
+
+  # Server Callbacks
+  @impl true
+  def init(state), do: {:ok, state}
+
+  @impl true
+  def handle_call(:balance, _from, state) do
+    {:reply, state.balance, state}
+  end
+
+  @impl true
+  def handle_call({:deposit, amount}, _from, state) when amount > 0 do
+    new_balance = state.balance + amount
+    {:reply, {:ok, new_balance}, %{state | balance: new_balance}}
+  end
+
+  @impl true
+  def handle_call({:withdraw, amount}, _from, state) do
+    if state.balance >= amount do
+      new_balance = state.balance - amount
+      {:reply, {:ok, new_balance}, %{state | balance: new_balance}}
+    else
+      {:reply, {:error, "残高不足"}, state}
+    end
+  end
+end
+```
+
+## Task（非同期処理）
+
+```elixir
+defmodule AsyncTasks do
+  def parallel_execute(functions) do
+    functions
+    |> Enum.map(&Task.async/1)
+    |> Enum.map(&Task.await/1)
+  end
+
+  def parallel_map(list, fun) do
+    list
+    |> Enum.map(fn item -> Task.async(fn -> fun.(item) end) end)
+    |> Enum.map(&Task.await/1)
+  end
+
+  def with_timeout(fun, timeout_ms) do
+    task = Task.async(fun)
+    case Task.yield(task, timeout_ms) || Task.shutdown(task) do
+      {:ok, result} -> {:ok, result}
+      nil -> {:error, :timeout}
+    end
+  end
+
+  def race(functions) do
+    parent = self()
+    pids = Enum.map(functions, fn fun ->
+      spawn(fn ->
+        result = fun.()
+        send(parent, {:result, self(), result})
+      end)
+    end)
+
+    receive do
+      {:result, _pid, result} ->
+        Enum.each(pids, fn pid ->
+          if Process.alive?(pid), do: Process.exit(pid, :kill)
+        end)
+        result
+    end
+  end
+end
+```
+
+## 並列処理パターン
+
+### Map-Reduce
+
+```elixir
+def map_reduce(data, mapper, reducer) do
+  data
+  |> Task.async_stream(mapper, ordered: false)
+  |> Enum.map(fn {:ok, result} -> result end)
+  |> reducer.()
+end
+
+# 使用例
+data = [1, 2, 3, 4, 5]
+map_reduce(data, &(&1 * 2), &Enum.sum/1)  # => 30
+```
+
+### ファンアウト・ファンイン
+
+```elixir
+def fan_out_fan_in(data, workers) do
+  workers
+  |> Enum.map(fn worker -> Task.async(fn -> worker.(data) end) end)
+  |> Enum.map(&Task.await/1)
+end
+```
+
+### バッチ処理
+
+```elixir
+def batch_process(data, batch_size, processor) do
+  data
+  |> Enum.chunk_every(batch_size)
+  |> Task.async_stream(processor)
+  |> Enum.map(fn {:ok, result} -> result end)
+end
+```
+
+## 同期パターン
+
+### セマフォ
+
+```elixir
+def semaphore(max_permits) do
+  Agent.start_link(fn -> max_permits end)
+end
+
+def acquire(sem) do
+  case Agent.get_and_update(sem, fn
+    0 -> {0, 0}
+    n -> {n, n - 1}
+  end) do
+    0 -> Process.sleep(10); acquire(sem)
+    _ -> :ok
+  end
+end
+
+def release(sem) do
+  Agent.update(sem, &(&1 + 1))
+end
+```
+
+### リソースプール
+
+```elixir
+def resource_pool(resources) do
+  Agent.start_link(fn -> resources end)
+end
+
+def borrow(pool) do
+  Agent.get_and_update(pool, fn
+    [] -> {{:error, :empty}, []}
+    [head | tail] -> {{:ok, head}, tail}
+  end)
+end
+
+def return(pool, resource) do
+  Agent.update(pool, fn resources -> [resource | resources] end)
+end
+```
+
+## イベントバス
+
+```elixir
+defmodule EventBus do
+  def start, do: Agent.start_link(fn -> %{} end)
+
+  def subscribe(bus, event_type, subscriber) do
+    Agent.update(bus, fn subscriptions ->
+      current = Map.get(subscriptions, event_type, [])
+      Map.put(subscriptions, event_type, [subscriber | current])
+    end)
+  end
+
+  def publish(bus, event_type, payload) do
+    subscribers = Agent.get(bus, fn subs -> Map.get(subs, event_type, []) end)
+    Enum.each(subscribers, fn sub -> send(sub, {:event, event_type, payload}) end)
+    :ok
+  end
+end
+```
+
+## まとめ
+
+- **プロセス**で軽量な並行処理
+- **Agent**で状態を安全に管理
+- **GenServer**でステートフルなサーバーを実装
+- **Task**で非同期処理を簡潔に
+- **並列パターン**（Map-Reduce、ファンアウト・ファンイン）で効率的な処理
+- **同期パターン**（セマフォ、リソースプール）で競合を制御
+
+## 関連リソース
+
+- [Elixir GenServer](https://hexdocs.pm/elixir/GenServer.html)
+- [Elixir Task](https://hexdocs.pm/elixir/Task.html)
+- [The Actor Model](https://www.youtube.com/watch?v=7erJ1DV_Tlo)