@k2works/claude-code-booster 6.1.0 → 6.3.0

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

@@ -1,278 +0,0 @@
----
-type: Article
-title: "Chapter 10: 並行処理パターン"
-description: "Elixir における並行処理パターンを学びます。"
-tags: [article, functional-desgin-ppp, elixir]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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)

package/lib/assets/docs/article/functional-desgin-ppp/elixir/11-command-pattern.md

@@ -1,157 +0,0 @@
----
-type: Article
-title: "第11章: Command パターン"
-description: "Command パターンは、リクエストをオブジェクト（データ）としてカプセル化し、異なるリクエストでクライアントをパラメータ化したり、操作の履歴を記録したり、Undo/Redo 機能を実装できるようにするパターンです。"
-tags: [article, functional-desgin-ppp, elixir]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第11章: Command パターン
-
-## はじめに
-
-Command パターンは、リクエストをオブジェクト（データ）としてカプセル化し、異なるリクエストでクライアントをパラメータ化したり、操作の履歴を記録したり、Undo/Redo 機能を実装できるようにするパターンです。
-
-Elixir では、プロトコルを使用してコマンドインターフェースを定義し、構造体でコマンドを表現します。
-
-## 1. Command プロトコル
-
-```elixir
-defprotocol Command do
-  @doc "コマンドを実行し、新しい状態を返す"
-  def execute(command, state)
-
-  @doc "コマンドを取り消し、以前の状態を返す"
-  def undo(command, state)
-end
-```
-
-## 2. テキスト操作コマンド
-
-### InsertCommand
-
-```elixir
-defmodule InsertCommand do
-  defstruct [:position, :text]
-
-  def new(position, text), do: %__MODULE__{position: position, text: text}
-end
-
-defimpl Command, for: InsertCommand do
-  def execute(%InsertCommand{position: pos, text: text}, document) do
-    before = String.slice(document, 0, pos)
-    after_text = String.slice(document, pos..-1//1)
-    before <> text <> after_text
-  end
-
-  def undo(%InsertCommand{position: pos, text: text}, document) do
-    len = String.length(text)
-    before = String.slice(document, 0, pos)
-    after_text = String.slice(document, (pos + len)..-1//1)
-    before <> after_text
-  end
-end
-```
-
-### 使用例
-
-```elixir
-cmd = InsertCommand.new(5, " World")
-result = Command.execute(cmd, "Hello")
-# => "Hello World"
-
-restored = Command.undo(cmd, "Hello World")
-# => "Hello"
-```
-
-## 3. コマンド実行器
-
-```elixir
-defmodule CommandExecutor do
-  defstruct [:state, undo_stack: [], redo_stack: []]
-
-  def new(initial_state), do: %__MODULE__{state: initial_state}
-
-  def execute(%__MODULE__{state: state, undo_stack: undo} = executor, command) do
-    new_state = Command.execute(command, state)
-    %{executor |
-      state: new_state,
-      undo_stack: [command | undo],
-      redo_stack: []
-    }
-  end
-
-  def undo(%__MODULE__{undo_stack: []} = executor), do: executor
-  def undo(%__MODULE__{state: state, undo_stack: [cmd | rest], redo_stack: redo} = executor) do
-    new_state = Command.undo(cmd, state)
-    %{executor |
-      state: new_state,
-      undo_stack: rest,
-      redo_stack: [cmd | redo]
-    }
-  end
-
-  def redo(%__MODULE__{redo_stack: []} = executor), do: executor
-  def redo(%__MODULE__{state: state, undo_stack: undo, redo_stack: [cmd | rest]} = executor) do
-    new_state = Command.execute(cmd, state)
-    %{executor |
-      state: new_state,
-      undo_stack: [cmd | undo],
-      redo_stack: rest
-    }
-  end
-end
-```
-
-## 4. マクロコマンド
-
-複数のコマンドを1つにまとめて実行：
-
-```elixir
-defmodule MacroCommand do
-  defstruct [:commands]
-
-  def new(commands), do: %__MODULE__{commands: commands}
-end
-
-defimpl Command, for: MacroCommand do
-  def execute(%MacroCommand{commands: commands}, state) do
-    Enum.reduce(commands, state, &Command.execute(&1, &2))
-  end
-
-  def undo(%MacroCommand{commands: commands}, state) do
-    Enum.reduce(Enum.reverse(commands), state, &Command.undo(&1, &2))
-  end
-end
-```
-
-## 5. キャンバス操作
-
-図形の追加・移動・削除もコマンドで表現：
-
-```elixir
-defmodule AddShapeCommand do
-  defstruct [:shape]
-end
-
-defimpl Command, for: AddShapeCommand do
-  def execute(%{shape: shape}, %{shapes: shapes} = canvas) do
-    %{canvas | shapes: shapes ++ [shape]}
-  end
-
-  def undo(%{shape: shape}, %{shapes: shapes} = canvas) do
-    %{canvas | shapes: Enum.reject(shapes, &(&1.id == shape.id))}
-  end
-end
-```
-
-## まとめ
-
-Elixir での Command パターンのポイント：
-
-- **Protocol** でコマンドインターフェースを定義
-- **Struct** でコマンドデータを表現
-- **不変性** を活かした状態管理
-- **Undo/Redo** スタックによる履歴管理
-- **MacroCommand** で複合操作をサポート

package/lib/assets/docs/article/functional-desgin-ppp/elixir/12-visitor-pattern.md

@@ -1,185 +0,0 @@
----
-type: Article
-title: "第12章: Visitor パターン"
-description: "Visitor パターンは、データ構造と操作を分離し、既存のデータ構造を変更することなく新しい操作を追加できるようにするパターンです。"
-tags: [article, functional-desgin-ppp, elixir]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第12章: Visitor パターン
-
-## はじめに
-
-Visitor パターンは、データ構造と操作を分離し、既存のデータ構造を変更することなく新しい操作を追加できるようにするパターンです。
-
-Elixir では、プロトコルを使用して Visitor インターフェースを定義し、各図形タイプに対する実装を提供します。
-
-## 1. Element: 図形の定義
-
-```elixir
-defmodule Circle do
-  defstruct [:center, :radius]
-  def new(center, radius), do: %__MODULE__{center: center, radius: radius}
-end
-
-defmodule Square do
-  defstruct [:top_left, :side]
-  def new(top_left, side), do: %__MODULE__{top_left: top_left, side: side}
-end
-
-defmodule Rectangle do
-  defstruct [:top_left, :width, :height]
-  def new(top_left, width, height) do
-    %__MODULE__{top_left: top_left, width: width, height: height}
-  end
-end
-```
-
-## 2. Visitor プロトコル
-
-```elixir
-defprotocol ShapeVisitor do
-  @doc "図形を訪問して処理を行う"
-  def visit(visitor, shape)
-end
-```
-
-## 3. JSON Visitor
-
-```elixir
-defmodule JsonVisitor do
-  defstruct []
-  def new, do: %__MODULE__{}
-
-  def to_json(shape), do: ShapeVisitor.visit(new(), shape)
-end
-
-defimpl ShapeVisitor, for: JsonVisitor do
-  def visit(_visitor, %Circle{center: {x, y}, radius: r}) do
-    ~s({"type":"circle","center":[#{x},#{y}],"radius":#{r}})
-  end
-
-  def visit(_visitor, %Square{top_left: {x, y}, side: s}) do
-    ~s({"type":"square","topLeft":[#{x},#{y}],"side":#{s}})
-  end
-
-  def visit(_visitor, %Rectangle{top_left: {x, y}, width: w, height: h}) do
-    ~s({"type":"rectangle","topLeft":[#{x},#{y}],"width":#{w},"height":#{h}})
-  end
-end
-```
-
-## 4. Area Visitor
-
-```elixir
-defmodule AreaVisitor do
-  defstruct []
-  def new, do: %__MODULE__{}
-
-  def calculate_area(shape), do: ShapeVisitor.visit(new(), shape)
-
-  def total_area(shapes) do
-    Enum.reduce(shapes, 0, &(&2 + calculate_area(&1)))
-  end
-end
-
-defimpl ShapeVisitor, for: AreaVisitor do
-  def visit(_visitor, %Circle{radius: r}) do
-    :math.pi() * r * r
-  end
-
-  def visit(_visitor, %Square{side: s}) do
-    s * s
-  end
-
-  def visit(_visitor, %Rectangle{width: w, height: h}) do
-    w * h
-  end
-end
-```
-
-## 5. Perimeter Visitor
-
-```elixir
-defmodule PerimeterVisitor do
-  defstruct []
-  def new, do: %__MODULE__{}
-
-  def calculate_perimeter(shape), do: ShapeVisitor.visit(new(), shape)
-end
-
-defimpl ShapeVisitor, for: PerimeterVisitor do
-  def visit(_visitor, %Circle{radius: r}), do: 2 * :math.pi() * r
-  def visit(_visitor, %Square{side: s}), do: 4 * s
-  def visit(_visitor, %Rectangle{width: w, height: h}), do: 2 * (w + h)
-end
-```
-
-## 6. SVG Visitor
-
-```elixir
-defmodule SvgVisitor do
-  defstruct fill: "none", stroke: "black", stroke_width: 1
-
-  def new(opts \\ []) do
-    %__MODULE__{
-      fill: Keyword.get(opts, :fill, "none"),
-      stroke: Keyword.get(opts, :stroke, "black"),
-      stroke_width: Keyword.get(opts, :stroke_width, 1)
-    }
-  end
-end
-
-defimpl ShapeVisitor, for: SvgVisitor do
-  def visit(%{fill: f, stroke: s, stroke_width: sw}, %Circle{center: {cx, cy}, radius: r}) do
-    ~s(<circle cx="#{cx}" cy="#{cy}" r="#{r}" fill="#{f}" stroke="#{s}" stroke-width="#{sw}"/>)
-  end
-  # ... 他の図形も同様
-end
-```
-
-## 7. 複合 Visitor
-
-```elixir
-defmodule CompositeVisitor do
-  def apply_all(shape, visitors) do
-    Map.new(visitors, fn {key, visitor} ->
-      {key, ShapeVisitor.visit(visitor, shape)}
-    end)
-  end
-end
-
-# 使用例
-results = CompositeVisitor.apply_all(circle, [
-  {:json, JsonVisitor.new()},
-  {:area, AreaVisitor.new()}
-])
-```
-
-## 8. DrawingContext
-
-```elixir
-defmodule DrawingContext do
-  defstruct shapes: []
-
-  def add_shape(ctx, shape), do: %{ctx | shapes: ctx.shapes ++ [shape]}
-
-  def to_json(%{shapes: shapes}) do
-    json_items = Enum.map(shapes, &JsonVisitor.to_json/1)
-    "[" <> Enum.join(json_items, ",") <> "]"
-  end
-
-  def total_area(%{shapes: shapes}), do: AreaVisitor.total_area(shapes)
-end
-```
-
-## まとめ
-
-Elixir での Visitor パターンのポイント：
-
-- **Protocol** で Visitor インターフェースを定義
-- **defimpl** で各図形タイプに対する実装を提供
-- 新しい操作を追加する際は新しい Visitor を作成
-- 既存の図形コードを変更せずに拡張可能
-- **CompositeVisitor** で複数の操作を一度に適用