@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/elixir/22-oo-to-fp-migration.md

@@ -0,0 +1,395 @@
+# 第22章: OO から FP への移行
+
+## はじめに
+
+オブジェクト指向プログラミング（OOP）から関数型プログラミング（FP）への移行パターンを解説します。既存の OOP 概念を Elixir でどのように表現するかを学びます。
+
+## 1. クラスからモジュールへ
+
+### OOP のクラス
+
+```python
+# Python での実装
+class BankAccount:
+    def __init__(self, owner, balance=0):
+        self.owner = owner
+        self.balance = balance
+
+    def deposit(self, amount):
+        self.balance += amount
+
+    def withdraw(self, amount):
+        if amount <= self.balance:
+            self.balance -= amount
+            return True
+        return False
+```
+
+### Elixir での実装
+
+```elixir
+defmodule BankAccount do
+  defstruct [:owner, balance: 0]
+
+  def new(owner, balance \\ 0) do
+    %__MODULE__{owner: owner, balance: balance}
+  end
+
+  def deposit(account, amount) when amount > 0 do
+    %{account | balance: account.balance + amount}
+  end
+
+  def withdraw(account, amount) when amount > 0 do
+    if amount <= account.balance do
+      {:ok, %{account | balance: account.balance - amount}}
+    else
+      {:error, :insufficient_funds}
+    end
+  end
+end
+```
+
+### 主な違い
+
+| OOP | FP (Elixir) |
+|-----|-------------|
+| インスタンスを変更 | 新しい値を返す |
+| `self.balance += amount` | `%{account | balance: ...}` |
+| `return True/False` | `{:ok, ...}` / `{:error, ...}` |
+
+## 2. 継承からコンポジションへ
+
+### OOP の継承
+
+```python
+class Animal:
+    def speak(self): pass
+
+class Dog(Animal):
+    def speak(self): return "Woof!"
+
+class Cat(Animal):
+    def speak(self): return "Meow!"
+```
+
+### Elixir のプロトコル
+
+```elixir
+defprotocol Speakable do
+  def speak(animal)
+end
+
+defmodule Dog do
+  defstruct [:name]
+end
+
+defmodule Cat do
+  defstruct [:name]
+end
+
+defimpl Speakable, for: Dog do
+  def speak(_dog), do: "Woof!"
+end
+
+defimpl Speakable, for: Cat do
+  def speak(_cat), do: "Meow!"
+end
+```
+
+### ビヘイビアによるインターフェース
+
+```elixir
+defmodule Serializable do
+  @callback to_json(term()) :: String.t()
+  @callback from_json(String.t()) :: {:ok, term()} | {:error, term()}
+end
+
+defmodule User do
+  @behaviour Serializable
+
+  @impl true
+  def to_json(%__MODULE__{id: id, name: name}) do
+    ~s({"id":#{id},"name":"#{name}"})
+  end
+
+  @impl true
+  def from_json(json) do
+    # パース処理
+  end
+end
+```
+
+### テンプレートメソッドの代替: 高階関数
+
+```elixir
+defmodule DataProcessor do
+  def process(data, opts \\ []) do
+    parser = Keyword.get(opts, :parser, &default_parse/1)
+    validator = Keyword.get(opts, :validator, &default_validate/1)
+
+    data
+    |> parser.()
+    |> validator.()
+  end
+end
+```
+
+## 3. ミュータブル状態からイミュータブル変換へ
+
+### OOP のミュータブル状態
+
+```python
+class ShoppingCart:
+    def __init__(self):
+        self.items = []
+
+    def add_item(self, item):
+        self.items.append(item)
+
+    def total(self):
+        return sum(i.price for i in self.items)
+```
+
+### Elixir のイミュータブル
+
+```elixir
+defmodule ShoppingCart do
+  defstruct items: []
+
+  def new, do: %__MODULE__{}
+
+  def add_item(cart, item) do
+    %{cart | items: [item | cart.items]}
+  end
+
+  def total(cart) do
+    cart.items
+    |> Enum.map(&(&1.price * &1.quantity))
+    |> Enum.sum()
+  end
+end
+```
+
+### 状態遷移パターン
+
+```elixir
+defmodule OrderState do
+  def transition(%{status: :pending} = order, :confirm) do
+    {:ok, Map.put(order, :status, :confirmed)}
+  end
+
+  def transition(%{status: :confirmed} = order, :ship) do
+    {:ok, Map.put(order, :status, :shipped)}
+  end
+
+  def transition(%{status: status}, action) do
+    {:error, {:invalid_transition, status, action}}
+  end
+end
+```
+
+### イベントソーシング
+
+```elixir
+defmodule Account do
+  defstruct [:id, :balance, :events]
+
+  def apply_event(account, {:deposited, amount, timestamp}) do
+    %{account |
+      balance: account.balance + amount,
+      events: [{:deposited, amount, timestamp} | account.events]
+    }
+  end
+
+  def deposit(account, amount) when amount > 0 do
+    event = {:deposited, amount, DateTime.utc_now()}
+    {:ok, apply_event(account, event)}
+  end
+
+  def replay(account, events) do
+    Enum.reduce(events, account, &apply_event(&2, &1))
+  end
+end
+```
+
+## 4. デザインパターンの変換
+
+### Strategy → 高階関数
+
+```elixir
+# OOP: Strategyインターフェースと実装クラス
+# FP: 関数を直接渡す
+def sort(items, comparator \\ &<=/2) do
+  Enum.sort(items, comparator)
+end
+
+# 事前定義された戦略
+def by_name, do: fn a, b -> a.name <= b.name end
+def by_price, do: fn a, b -> a.price <= b.price end
+```
+
+### Observer → メッセージパッシング
+
+```elixir
+defmodule EventNotifier do
+  use GenServer
+
+  def subscribe(pid, subscriber) do
+    GenServer.call(pid, {:subscribe, subscriber})
+  end
+
+  def notify(pid, event) do
+    GenServer.cast(pid, {:notify, event})
+  end
+
+  @impl true
+  def handle_cast({:notify, event}, state) do
+    Enum.each(state.subscribers, fn {_id, sub} ->
+      send(sub, {:event, event})
+    end)
+    {:noreply, state}
+  end
+end
+```
+
+### Decorator → 関数合成
+
+```elixir
+def log(message), do: "[LOG] #{message}"
+
+def with_timestamp(log_fn) do
+  fn message ->
+    timestamp = DateTime.utc_now() |> DateTime.to_string()
+    log_fn.("[#{timestamp}] #{message}")
+  end
+end
+
+def with_level(log_fn, level) do
+  fn message ->
+    log_fn.("[#{level}] #{message}")
+  end
+end
+
+# 合成
+logger = (&log/1) |> with_timestamp() |> with_level(:info)
+```
+
+### Command → データ
+
+```elixir
+def execute({:create_user, name, email}) do
+  {:ok, %{id: generate_id(), name: name, email: email}}
+end
+
+def execute({:delete_user, id}) do
+  {:ok, {:deleted, id}}
+end
+
+# バッチ実行
+def execute_batch(commands) do
+  Enum.map(commands, &execute/1)
+end
+```
+
+### Visitor → パターンマッチ
+
+```elixir
+# 式の評価
+def eval({:number, n}), do: n
+def eval({:add, a, b}), do: eval(a) + eval(b)
+def eval({:mul, a, b}), do: eval(a) * eval(b)
+
+# 式の最適化
+def optimize({:add, {:number, 0}, b}), do: optimize(b)
+def optimize({:mul, {:number, 1}, b}), do: optimize(b)
+def optimize({:mul, {:number, 0}, _}), do: {:number, 0}
+def optimize(expr), do: expr
+```
+
+## 5. 実践的な移行例
+
+### ユーザー管理システム
+
+```elixir
+# データ定義
+defmodule User do
+  defstruct [:id, :name, :email, :role, :active, created_at: nil]
+
+  def new(attrs) do
+    Map.merge(%__MODULE__{
+      id: generate_id(),
+      active: true,
+      created_at: DateTime.utc_now()
+    }, Map.new(attrs))
+  end
+end
+
+# 変換関数（純粋）
+defmodule Transformations do
+  def activate(user), do: %{user | active: true}
+  def deactivate(user), do: %{user | active: false}
+
+  def change_role(user, role) when role in [:admin, :user, :guest] do
+    {:ok, %{user | role: role}}
+  end
+end
+
+# クエリ関数（純粋）
+defmodule Queries do
+  def active_users(users), do: Enum.filter(users, & &1.active)
+  def by_role(users, role), do: Enum.filter(users, &(&1.role == role))
+end
+
+# リポジトリ（状態あり）
+defmodule Repository do
+  use Agent
+
+  def add(user), do: Agent.update(__MODULE__, &Map.put(&1, user.id, user))
+  def get(id), do: Agent.get(__MODULE__, &Map.get(&1, id))
+end
+
+# サービス層
+defmodule Service do
+  def create_user(attrs) do
+    user = User.new(attrs)
+    Repository.add(user)
+    {:ok, user}
+  end
+
+  def promote_to_admin(user_id) do
+    with user when not is_nil(user) <- Repository.get(user_id),
+         {:ok, updated} <- Transformations.change_role(user, :admin) do
+      Repository.update(updated)
+      {:ok, updated}
+    else
+      nil -> {:error, :not_found}
+      error -> error
+    end
+  end
+end
+```
+
+## 6. 移行のガイドライン
+
+| OOP 概念 | FP 代替 |
+|---------|---------|
+| クラス | モジュール + 構造体 |
+| インスタンス変数 | 構造体のフィールド |
+| メソッド | モジュール関数 |
+| 継承 | プロトコル、ビヘイビア |
+| ポリモーフィズム | パターンマッチ |
+| ミュータブル状態 | 変換関数、GenServer/Agent |
+| 例外 | タグ付きタプル |
+| null | `nil` + パターンマッチ |
+
+## まとめ
+
+OOP から FP への移行で重要なポイント：
+
+1. **データと振る舞いの分離**: 構造体はデータのみ、関数は変換
+2. **不変性の受け入れ**: 変更ではなく新しい値を生成
+3. **明示的な状態管理**: GenServer/Agent で状態を局所化
+4. **パターンマッチの活用**: 条件分岐をデータ構造で表現
+5. **関数の合成**: 小さな純粋関数を組み合わせる
+
+最初は違和感がありますが、慣れると FP の方が理解しやすく、テストしやすいコードになります。

package/lib/assets/docs/article/functional-desgin-ppp/elixir/index.md

@@ -0,0 +1,204 @@
+# Elixir で学ぶ関数型デザイン
+
+## はじめに
+
+本記事シリーズは、関数型プログラミングにおける設計原則とデザインパターンを Elixir を使って実践的に学ぶためのガイドです。Elixir は Erlang VM 上で動作する関数型言語であり、不変データ、パターンマッチング、並行処理に優れた特性を持っています。これらの特性を活かし、従来のデザインパターンを関数型パラダイムでどのように表現し、活用できるかを探求します。
+
+## 記事構成
+
+### 第1部: 関数型プログラミングの基礎原則
+
+1. [不変性とデータ変換](./01-immutability-and-data-transformation.md)
+    - マップと構造体による不変データ
+    - パイプ演算子によるデータ変換
+    - Enum と Stream による遅延評価
+
+2. [関数合成と高階関数](./02-function-composition.md)
+    - 無名関数とキャプチャ演算子
+    - 関数合成のパターン
+    - 高階関数の活用
+
+3. [多態性の実現方法](./03-polymorphism.md)
+    - プロトコルによる多態性
+    - ビヘイビアとコールバック
+    - パターンマッチングによる型の切り替え
+
+### 第2部: 仕様とテスト
+
+4. [データ検証](./04-data-validation.md)
+    - Ecto.Changeset によるバリデーション
+    - カスタムバリデータの作成
+    - with 式によるエラーハンドリング
+
+5. [プロパティベーステスト](./05-property-based-testing.md)
+    - StreamData の基本
+    - ジェネレータの作成
+    - プロパティの定義と検証
+
+6. [TDD と関数型プログラミング](./06-tdd-functional.md)
+    - ExUnit によるテスト
+    - Red-Green-Refactor サイクル
+    - ドキュメントテスト（doctest）
+
+### 第3部: 構造パターン
+
+7. [Composite パターン](./07-composite-pattern.md)
+    - 再帰的なデータ構造
+    - ネストした構造の操作
+    - アキュムレータを使った走査
+
+8. [Decorator パターン](./08-decorator-pattern.md)
+    - 関数合成によるデコレーション
+    - 高階関数でのラッピング
+    - マクロによる振る舞いの追加
+
+9. [Adapter パターン](./09-adapter-pattern.md)
+    - 関数アダプター
+    - プロトコル変換
+    - レガシーコードとの統合
+
+### 第4部: 振る舞いパターン
+
+10. [Strategy パターン](./10-strategy-pattern.md)
+    - 第一級関数としての戦略
+    - モジュールによる戦略実装
+    - 動的な戦略切り替え
+
+11. [Command パターン](./11-command-pattern.md)
+    - 不変コマンドデータ
+    - コマンドの履歴と Undo
+    - GenServer によるコマンド管理
+
+12. [Visitor パターン](./12-visitor-pattern.md)
+    - パターンマッチによる訪問
+    - プロトコルベースのビジター
+    - Enum.reduce による走査
+
+### 第5部: 生成パターン
+
+13. [Abstract Factory パターン](./13-abstract-factory-pattern.md)
+    - 関数ファクトリー
+    - モジュールベースの生成
+    - 設定による依存性注入
+
+14. [Abstract Server パターン](./14-abstract-server-pattern.md)
+    - ビヘイビアによる抽象化
+    - 実装の差し替え
+    - テスタブルな設計
+
+### 第6部: ケーススタディ
+
+15. [ゴシップ好きなバスの運転手](./15-gossiping-bus-drivers.md)
+    - Agent による状態管理
+    - シミュレーションの実装
+    - 再帰的な処理
+
+16. [給与計算システム](./16-payroll-system.md)
+    - ドメインモデリング
+    - 多態的な計算
+    - レポート生成
+
+17. [レンタルビデオシステム](./17-video-rental-system.md)
+    - 状態遷移の管理
+    - イベントソーシング
+    - ビジネスルールの実装
+
+18. [並行処理システム](./18-concurrency-system.md)
+    - GenServer による状態管理
+    - Task による並行実行
+    - OTP パターン
+
+19. [Wa-Tor シミュレーション](./19-wator-simulation.md)
+    - セルオートマトン
+    - 不変グリッドの更新
+    - プロセスベースのシミュレーション
+
+### 第7部: まとめと応用
+
+20. [パターン間の相互作用](./20-pattern-interactions.md)
+    - Composite + Decorator
+    - Command + Observer
+    - パターンの組み合わせ
+
+21. [ベストプラクティス](./21-best-practices.md)
+    - データ中心設計
+    - 純粋関数の分離
+    - OTP パターンの活用
+    - テスタブルな設計
+
+22. [OO から FP への移行](./22-oo-to-fp-migration.md)
+    - 移行戦略（Strangler Fig、アダプター）
+    - イベントソーシング
+    - 段階的な関数抽出
+    - プロトコルによる多態性
+
+---
+
+## 本シリーズの特徴
+
+### Elixir の特性を活かした実装
+
+Elixir の強力な機能（パターンマッチング、パイプ演算子、プロトコル、OTP など）を活用し、実践的な関数型プログラミングを学びます。
+
+### 並行処理の自然な統合
+
+Elixir は Erlang VM 上で動作するため、並行処理が言語の中核に組み込まれています。アクターモデルと不変性により、スケーラブルで堅牢なシステムを構築する方法を学びます。
+
+### 実践重視
+
+すべてのパターンは ExUnit による実際に動作するテストコードを含みます。理論だけでなく、実装を通じて理解を深めることを重視しています。
+
+### 段階的な学習
+
+基礎から応用へと段階的に内容が進行します。各章は独立して読むこともできますが、順番に読むことでより深い理解が得られます。
+
+---
+
+## 対象読者
+
+- 関数型プログラミングに興味がある Elixir 開発者
+- Elixir を学習中の開発者
+- オブジェクト指向デザインパターンの知識があり、関数型での表現を学びたい開発者
+- Clojure 版や他言語版と比較して学習したい開発者
+
+---
+
+## 前提知識
+
+- プログラミングの基礎知識
+- Elixir の基本的な文法（マップ、構造体、パターンマッチングなど）
+- デザインパターンの基本概念（推奨）
+
+---
+
+## 開発環境
+
+本シリーズのコードは以下の環境で動作確認しています：
+
+- Elixir 1.16+
+- Erlang/OTP 26+
+- Mix ビルドツール
+- ExUnit テストフレームワーク
+- Nix による環境管理
+
+### 環境構築
+
+```bash
+# Nix を使用した開発環境の起動
+nix develop .#elixir
+
+# テストの実行
+cd apps/elixir/part1
+mix test
+```
+
+---
+
+## 参考書籍
+
+本シリーズは以下の書籍の内容を参考にしています：
+
+- 「Functional Design: Principles, Patterns, and Practices」Robert C. Martin
+- 「Programming Elixir」Dave Thomas
+- 「Elixir in Action」Saša Jurić
+- 「Designing Elixir Systems with OTP」James Edward Gray II, Bruce A. Tate