@k2works/claude-code-booster 3.5.0 → 3.6.0

package/lib/assets/docs/article/functional-desgin-ppp/elixir/07-effects-and-pure-functions.md

@@ -1,164 +1,164 @@
-# Chapter 07: 副作用と純粋関数
-
-Elixir における副作用の管理と純粋関数の分離について学びます。
-
-## 概要
-
-関数型プログラミングでは、副作用（I/O、状態変更、時間、乱数）を純粋なビジネスロジックから分離することが重要です。このチャプターでは、その設計パターンを紹介します。
-
-## 主なトピック
-
-1. **純粋関数と副作用の分離**
-2. **Functional Core, Imperative Shell**
-3. **副作用の遅延実行**
-4. **Reader パターン**
-5. **依存性注入**
-
-## 純粋関数 vs 副作用
-
-### 純粋関数
-
-- 同じ入力に対して常に同じ出力
-- 外部状態を変更しない
-
-```elixir
-# 純粋関数の例
-def add(a, b), do: a + b
-def upcase(s), do: String.upcase(s)
-```
-
-### 副作用を持つ関数
-
-- I/O（コンソール、ファイル、ネットワーク）
-- 状態変更
-- 現在時刻の取得
-- 乱数生成
-
-```elixir
-# 副作用を持つ関数
-def current_time, do: DateTime.utc_now()  # 非決定的
-def random_number, do: :rand.uniform()    # 非決定的
-def print(msg), do: IO.puts(msg)          # I/O
-```
-
-## Functional Core, Imperative Shell
-
-ビジネスロジックを純粋関数として実装し、副作用は境界層で処理します。
-
-```elixir
-# Functional Core（純粋関数）
-defmodule PricingCore do
-  def apply_discount(price, %{type: :percentage, value: pct}) do
-    price * (1 - pct / 100)
-  end
-
-  def calculate_total(products) do
-    products |> Enum.map(& &1.price) |> Enum.sum()
-  end
-end
-
-# Imperative Shell（副作用を扱う）
-defmodule PricingShell do
-  def calculate_order_price(products, discount_fetcher, discount_code, tax_rate) do
-    # 副作用：外部から割引情報を取得
-    discount = discount_fetcher.(discount_code)
-    # 純粋関数でビジネスロジックを実行
-    PricingCore.calculate_final_price(products, discount, tax_rate)
-  end
-end
-```
-
-## 副作用の遅延実行（Effect as Data）
-
-副作用をデータとして表現し、実行を遅延させます。
-
-```elixir
-defmodule Effect do
-  def console_log(message) do
-    {:effect, :console_log, message, fn _ -> :ok end}
-  end
-
-  def get_current_time do
-    {:effect, :get_time, nil, fn time -> time end}
-  end
-
-  # 本番用インタープリター
-  def run({:effect, :console_log, message, cont}) do
-    IO.puts(message)
-    cont.(:ok)
-  end
-
-  # テスト用インタープリター
-  def run_test({:effect, effect_type, _, cont}, mock_values) do
-    cont.(Map.get(mock_values, effect_type))
-  end
-end
-```
-
-## Reader パターン
-
-環境（設定、依存性）を引数として渡す関数をラップします。
-
-```elixir
-defmodule Reader do
-  def pure(value), do: fn _env -> value end
-  def ask, do: fn env -> env end
-  def asks(selector), do: fn env -> selector.(env) end
-
-  def flat_map(reader, f) do
-    fn env -> f.(reader.(env)).(env) end
-  end
-
-  def run(reader, env), do: reader.(env)
-end
-
-# 使用例
-def get_db_url do
-  Reader.asks(fn config -> config.db_url end)
-end
-
-def build_service do
-  Reader.flat_map(get_db_url(), fn db_url ->
-    Reader.flat_map(get_api_key(), fn api_key ->
-      Reader.pure(%{db: db_url, key: api_key, ready: true})
-    end)
-  end)
-end
-```
-
-## 時間の抽象化
-
-時間依存をテスト可能にします。
-
-```elixir
-defmodule TimeService do
-  def add_timestamp(data, time_provider) do
-    Map.put(data, :timestamp, time_provider.())
-  end
-
-  def is_expired?(expiry_date, time_provider) do
-    DateTime.compare(time_provider.(), expiry_date) == :gt
-  end
-end
-
-# テスト
-test "is_expired? は期限切れを判定する" do
-  now = ~U[2024-01-15 12:00:00Z]
-  provider = fn -> now end
-
-  assert TimeService.is_expired?(~U[2024-01-10 12:00:00Z], provider) == true
-  assert TimeService.is_expired?(~U[2024-01-20 12:00:00Z], provider) == false
-end
-```
-
-## まとめ
-
-- **純粋関数**でビジネスロジックを実装
-- **Functional Core, Imperative Shell**で副作用を分離
-- **依存性注入**でテスト可能な設計
-- **Reader パターン**で環境を引き回す
-
-## 関連リソース
-
-- [Boundaries by Gary Bernhardt](https://www.destroyallsoftware.com/talks/boundaries)
-- [Functional Core, Imperative Shell](https://www.youtube.com/watch?v=yTkzNHF6rMs)
+# Chapter 07: 副作用と純粋関数
+
+Elixir における副作用の管理と純粋関数の分離について学びます。
+
+## 概要
+
+関数型プログラミングでは、副作用（I/O、状態変更、時間、乱数）を純粋なビジネスロジックから分離することが重要です。このチャプターでは、その設計パターンを紹介します。
+
+## 主なトピック
+
+1. **純粋関数と副作用の分離**
+2. **Functional Core, Imperative Shell**
+3. **副作用の遅延実行**
+4. **Reader パターン**
+5. **依存性注入**
+
+## 純粋関数 vs 副作用
+
+### 純粋関数
+
+- 同じ入力に対して常に同じ出力
+- 外部状態を変更しない
+
+```elixir
+# 純粋関数の例
+def add(a, b), do: a + b
+def upcase(s), do: String.upcase(s)
+```
+
+### 副作用を持つ関数
+
+- I/O（コンソール、ファイル、ネットワーク）
+- 状態変更
+- 現在時刻の取得
+- 乱数生成
+
+```elixir
+# 副作用を持つ関数
+def current_time, do: DateTime.utc_now()  # 非決定的
+def random_number, do: :rand.uniform()    # 非決定的
+def print(msg), do: IO.puts(msg)          # I/O
+```
+
+## Functional Core, Imperative Shell
+
+ビジネスロジックを純粋関数として実装し、副作用は境界層で処理します。
+
+```elixir
+# Functional Core（純粋関数）
+defmodule PricingCore do
+  def apply_discount(price, %{type: :percentage, value: pct}) do
+    price * (1 - pct / 100)
+  end
+
+  def calculate_total(products) do
+    products |> Enum.map(& &1.price) |> Enum.sum()
+  end
+end
+
+# Imperative Shell（副作用を扱う）
+defmodule PricingShell do
+  def calculate_order_price(products, discount_fetcher, discount_code, tax_rate) do
+    # 副作用：外部から割引情報を取得
+    discount = discount_fetcher.(discount_code)
+    # 純粋関数でビジネスロジックを実行
+    PricingCore.calculate_final_price(products, discount, tax_rate)
+  end
+end
+```
+
+## 副作用の遅延実行（Effect as Data）
+
+副作用をデータとして表現し、実行を遅延させます。
+
+```elixir
+defmodule Effect do
+  def console_log(message) do
+    {:effect, :console_log, message, fn _ -> :ok end}
+  end
+
+  def get_current_time do
+    {:effect, :get_time, nil, fn time -> time end}
+  end
+
+  # 本番用インタープリター
+  def run({:effect, :console_log, message, cont}) do
+    IO.puts(message)
+    cont.(:ok)
+  end
+
+  # テスト用インタープリター
+  def run_test({:effect, effect_type, _, cont}, mock_values) do
+    cont.(Map.get(mock_values, effect_type))
+  end
+end
+```
+
+## Reader パターン
+
+環境（設定、依存性）を引数として渡す関数をラップします。
+
+```elixir
+defmodule Reader do
+  def pure(value), do: fn _env -> value end
+  def ask, do: fn env -> env end
+  def asks(selector), do: fn env -> selector.(env) end
+
+  def flat_map(reader, f) do
+    fn env -> f.(reader.(env)).(env) end
+  end
+
+  def run(reader, env), do: reader.(env)
+end
+
+# 使用例
+def get_db_url do
+  Reader.asks(fn config -> config.db_url end)
+end
+
+def build_service do
+  Reader.flat_map(get_db_url(), fn db_url ->
+    Reader.flat_map(get_api_key(), fn api_key ->
+      Reader.pure(%{db: db_url, key: api_key, ready: true})
+    end)
+  end)
+end
+```
+
+## 時間の抽象化
+
+時間依存をテスト可能にします。
+
+```elixir
+defmodule TimeService do
+  def add_timestamp(data, time_provider) do
+    Map.put(data, :timestamp, time_provider.())
+  end
+
+  def is_expired?(expiry_date, time_provider) do
+    DateTime.compare(time_provider.(), expiry_date) == :gt
+  end
+end
+
+# テスト
+test "is_expired? は期限切れを判定する" do
+  now = ~U[2024-01-15 12:00:00Z]
+  provider = fn -> now end
+
+  assert TimeService.is_expired?(~U[2024-01-10 12:00:00Z], provider) == true
+  assert TimeService.is_expired?(~U[2024-01-20 12:00:00Z], provider) == false
+end
+```
+
+## まとめ
+
+- **純粋関数**でビジネスロジックを実装
+- **Functional Core, Imperative Shell**で副作用を分離
+- **依存性注入**でテスト可能な設計
+- **Reader パターン**で環境を引き回す
+
+## 関連リソース
+
+- [Boundaries by Gary Bernhardt](https://www.destroyallsoftware.com/talks/boundaries)
+- [Functional Core, Imperative Shell](https://www.youtube.com/watch?v=yTkzNHF6rMs)

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

@@ -1,168 +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)
+# 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)