@k2works/claude-code-booster 6.1.0 → 6.3.0

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

@@ -1,173 +0,0 @@
----
-type: Article
-title: "Chapter 07: 副作用と純粋関数"
-description: "Elixir における副作用の管理と純粋関数の分離について学びます。"
-tags: [article, functional-desgin-ppp, elixir]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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,177 +0,0 @@
----
-type: Article
-title: "Chapter 08: エラーハンドリング戦略"
-description: "Elixir における関数型エラーハンドリングパターンを学びます。"
-tags: [article, functional-desgin-ppp, elixir]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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

@@ -1,263 +0,0 @@
----
-type: Article
-title: "Chapter 09: I/O と外部システム"
-description: "Elixir における I/O 操作と外部システムとの連携を関数型に扱う方法を学びます。"
-tags: [article, functional-desgin-ppp, elixir]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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)