@k2works/claude-code-booster 6.1.0 → 6.3.0

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

@@ -1,404 +0,0 @@
----
-type: Article
-title: "第22章: OO から FP への移行"
-description: "オブジェクト指向プログラミング（OOP）から関数型プログラミング（FP）への移行パターンを解説します。"
-tags: [article, functional-desgin-ppp, elixir]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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

@@ -1,248 +0,0 @@
-# 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-and-fp.md)
-
-
-    - TDD の基本サイクル
-    - テスタブルな設計
-    - 純粋関数によるビジネスロジック
-
-### 第3部: 副作用と外部システム
-
-7. [副作用と純粋関数](./07-effects-and-pure-functions.md)
-
-
-    - 純粋関数 vs 副作用
-    - Functional Core, Imperative Shell
-    - 副作用の遅延実行（Effect as Data）
-
-8. [エラーハンドリング戦略](./08-error-handling-strategies.md)
-
-
-    - Result 型
-    - Validated パターン
-    - エラードメインモデリング
-
-9. [I/O と外部システム](./09-io-and-external-systems.md)
-
-
-    - コンソール I/O の抽象化
-    - ファイルシステムの抽象化
-    - リポジトリパターン
-
-10. [並行処理パターン](./10-concurrency-patterns.md)
-
-
-    - 基本的なプロセス
-    - Agent（状態管理）
-    - GenServer / Task
-
-### 第4部: 振る舞いパターン
-
-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