@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,197 @@
+# 関数型デザイン - 原則、パターン、実践
+
+## はじめに
+
+本記事シリーズは、関数型プログラミングにおける設計原則とデザインパターンを実践的に学ぶためのガイドです。Clojure を主な実装言語として、従来のオブジェクト指向デザインパターンを関数型パラダイムでどのように表現し、活用できるかを探求します。
+
+## 記事構成
+
+### 第1部: 関数型プログラミングの基礎原則
+
+1. [不変性とデータ変換](./01-immutability-and-data-transformation.md)
+    - 不変データ構造の重要性
+    - データ変換パイプライン
+    - 副作用の分離
+
+2. [関数合成と高階関数](./02-function-composition.md)
+    - 関数合成の基本
+    - 部分適用とカリー化
+    - 高階関数の活用
+
+3. [多態性の実現方法](./03-polymorphism.md)
+    - マルチメソッドによるディスパッチ
+    - プロトコルとレコード
+    - マルチメソッド vs プロトコルの使い分け
+
+### 第2部: 仕様とテスト
+
+4. [Clojure Spec による仕様定義](./04-clojure-spec.md)
+    - データ構造の仕様定義
+    - 関数仕様の定義（fdef）
+    - 実行時検証と自動テスト生成
+
+5. [プロパティベーステスト](./05-property-based-testing.md)
+    - test.check の基本
+    - ジェネレータの作成
+    - プロパティの定義と検証
+
+6. [テスト駆動開発と関数型プログラミング](./06-tdd-in-functional.md)
+    - Red-Green-Refactor サイクル
+    - テストファーストの関数設計
+    - リファクタリングと不変性
+
+### 第3部: デザインパターン - 構造パターン
+
+7. [Composite パターン](./07-composite-pattern.md)
+    - 個別オブジェクトと複合オブジェクトの統一的な扱い
+    - Shape（図形）の移動・拡大を統一インターフェースで操作
+    - Switchable（スイッチ）のグループ化と一括操作
+    - マルチメソッドによる多態性の実現
+
+8. [Decorator パターン](./08-decorator-pattern.md)
+    - 機能の動的な追加
+    - JournaledShape: 操作履歴の記録（ジャーナリング）
+    - 関数デコレータ: ログ、リトライ、キャッシュ
+    - デコレータの組み合わせ
+
+9. [Adapter パターン](./09-adapter-pattern.md)
+    - インターフェースの変換
+    - VariableLightAdapter: 可変強度ライトをオン/オフに適応
+    - データフォーマットアダプター: 新旧フォーマット変換
+    - マルチメソッドによる適応
+
+### 第4部: デザインパターン - 振る舞いパターン
+
+10. [Strategy パターン](./10-strategy-pattern.md)
+    - アルゴリズムをカプセル化し交換可能にする
+    - 料金計算: 通常・割引・会員・数量割引の各戦略
+    - 関数型アプローチ: 高階関数による戦略の合成
+    - マルチメソッドによる多態性の実現
+
+11. [Command パターン](./11-command-pattern.md)
+    - 操作をデータとしてカプセル化
+    - テキストコマンド: 挿入・削除・置換
+    - キャンバスコマンド: 図形の追加・削除・移動
+    - Undo/Redo 機能と MacroCommand
+
+12. [Visitor パターン](./12-visitor-pattern.md)
+    - データ構造と操作の分離
+    - JSON/XML 変換 Visitor の実装
+    - 面積・周囲長計算 Visitor
+    - マルチメソッドによるダブルディスパッチ
+
+### 第5部: デザインパターン - 生成パターン
+
+13. [Abstract Factory パターン](./13-abstract-factory-pattern.md)
+    - 関連するオブジェクトのファミリーを一貫して生成
+    - ShapeFactory: Standard/Outlined/Filled の各実装
+    - UIFactory: プラットフォーム別 UI コンポーネント生成
+    - マルチメソッドによる製品生成のディスパッチ
+
+14. [Abstract Server パターン](./14-abstract-server-pattern.md)
+    - 依存関係逆転の原則（DIP）の実現
+    - Switchable: Light/Fan/Motor の統一インターフェース
+    - Repository: データアクセスの抽象化
+    - プロトコルとレコードによる疎結合
+
+### 第6部: 実践的なケーススタディ
+
+15. [ゴシップ好きなバスの運転手](./15-gossiping-bus-drivers.md)
+    - バス運転手が停留所で噂を共有するシミュレーション
+    - 無限シーケンス（cycle）による循環ルート表現
+    - 集合演算による噂の伝播
+    - 状態変換パイプラインの実装
+
+16. [給与計算システム](./16-payroll-system.md)
+    - ドメインモデリング
+    - 支払いスケジュールと給与タイプ
+    - Clojure Spec によるデータ検証
+
+17. [レンタルビデオシステム](./17-video-rental-system.md)
+    - 料金計算ロジックの設計
+    - ポリシーパターンの適用
+    - テキスト/HTML フォーマッターの実装
+
+18. [並行処理システム](./18-concurrency-system.md)
+    - Clojure エージェントによる非同期処理
+    - 状態機械パターン
+    - イベント駆動アーキテクチャ
+
+19. [Wa-Tor シミュレーション](./19-wator-simulation.md)
+    - 捕食者-被食者モデルの実装
+    - セルオートマトンとマルチメソッド
+    - GUI との統合（Quil）
+    - 進化と繁殖のルール実装
+
+### 第7部: まとめと応用
+
+20. [パターン間の相互作用](./20-pattern-interactions.md)
+    - Composite と Decorator の組み合わせ
+    - Command と Observer の連携
+    - 複合的なアーキテクチャ設計
+
+21. [関数型デザインのベストプラクティス](./21-best-practices.md)
+    - データ中心設計
+    - 純粋関数と副作用の分離
+    - テスト可能な設計
+
+22. [オブジェクト指向から関数型への移行](./22-oo-to-fp-migration.md)
+    - 既存コードのリファクタリング戦略
+    - 段階的な移行アプローチ
+    - 共存と統合
+
+---
+
+## 付録
+
+- [用語集](./appendix-glossary.md)
+- [参考文献](./appendix-references.md)
+- [Clojure 開発環境セットアップ](./appendix-setup.md)
+
+---
+
+## 本シリーズの特徴
+
+### 実践重視
+
+すべてのパターンは実際に動作するコード例を含みます。理論だけでなく、実装を通じて理解を深めることを重視しています。
+
+### テスト駆動
+
+各パターンの実装にはテストコードが付属しています。TDD のアプローチに従い、テストファーストでパターンを学びます。
+
+### 段階的な学習
+
+基礎から応用へと段階的に内容が進行します。各章は独立して読むこともできますが、順番に読むことでより深い理解が得られます。
+
+### 日本語での解説
+
+技術用語は英語を併記しつつ、解説は日本語で行います。日本語でのデザインパターン学習リソースとして活用できます。
+
+---
+
+## 対象読者
+
+- 関数型プログラミングに興味がある開発者
+- Clojure を学習中または活用している開発者
+- オブジェクト指向デザインパターンの知識があり、関数型での表現を学びたい開発者
+- テスト駆動開発やクリーンコードに関心がある開発者
+
+---
+
+## 前提知識
+
+- プログラミングの基礎知識
+- Clojure の基本的な文法（リスト、マップ、関数定義など）
+- デザインパターンの基本概念（推奨）
+
+---
+
+## 参考書籍
+
+本シリーズは以下の書籍の内容を参考にしています：
+
+- 「Functional Design: Principles, Patterns, and Practices」Robert C. Martin
+- 「Clean Code」Robert C. Martin
+- 「Clojure Applied」Ben Vandgrift, Alex Miller
+- 「Programming Clojure」Alex Miller, Stuart Halloway, Aaron Bedra

package/lib/assets/docs/article/functional-desgin-ppp/elixir/01-immutability-and-data-transformation.md

@@ -0,0 +1,381 @@
+# 第1章: 不変性とデータ変換
+
+## はじめに
+
+関数型プログラミングの最も重要な概念の一つが**不変性（Immutability）**です。不変データ構造を使用することで、プログラムの予測可能性が向上し、並行処理でのバグを防ぎ、コードの理解と保守が容易になります。
+
+本章では、Elixir における不変データ構造の基本から、パイプ演算子によるデータ変換、副作用の分離まで、実践的な例を通じて学びます。
+
+## 1. 不変データ構造の基本
+
+### なぜ不変性が重要なのか
+
+Elixir ではすべてのデータがデフォルトで不変です。データを「変更」すると、常に新しいデータ構造が作成されます：
+
+```elixir
+defmodule Person do
+  @enforce_keys [:name, :age]
+  defstruct [:name, :age]
+end
+
+def update_age(%Person{} = person, new_age) do
+  %{person | age: new_age}
+end
+
+# 使用例
+original_person = %Person{name: "田中", age: 30}
+updated_person = update_age(original_person, 31)
+
+original_person   # => %Person{name: "田中", age: 30}  ← 元のデータは変わらない
+updated_person    # => %Person{name: "田中", age: 31}  ← 新しいデータ
+```
+
+### 不変性の利点
+
+1. **予測可能性**: データが変更されないため、関数の動作を予測しやすい
+2. **スレッドセーフ**: 複数のプロセスから安全にアクセスできる
+3. **履歴の保持**: 変更前のデータを保持できる（Undo/Redo の実装が容易）
+4. **デバッグの容易さ**: データの変更履歴を追跡しやすい
+
+## 2. 構造共有（Structural Sharing）
+
+「毎回新しいデータ構造を作成すると非効率では？」と思うかもしれません。Elixir の永続的データ構造は**構造共有**により、効率的にメモリを使用します。
+
+```elixir
+defmodule Member do
+  defstruct [:name, :role]
+end
+
+defmodule Team do
+  defstruct [:name, :members]
+end
+
+def add_member(%Team{members: members} = team, %Member{} = member) do
+  %{team | members: members ++ [member]}
+end
+
+team = %Team{name: "開発チーム", members: [
+  %Member{name: "田中", role: "developer"},
+  %Member{name: "鈴木", role: "designer"},
+  %Member{name: "佐藤", role: "manager"}
+]}
+
+new_team = add_member(team, %Member{name: "山田", role: "developer"})
+```
+
+`new_team` は新しい Team ですが、`name` の値や既存のメンバーデータは `team` と共有されています。変更されていない部分はコピーされず、参照が共有されます。
+
+```plantuml
+@startuml
+title 構造共有（Structural Sharing）
+
+object "team" as team {
+  name = "開発チーム"
+}
+
+object "new_team" as newTeam {
+  name = "開発チーム"
+}
+
+object "List(田中, 鈴木, 佐藤)" as oldList
+object "山田" as newMember
+
+team --> oldList : members
+newTeam --> oldList : 共有
+newTeam --> newMember : 新規追加のみ
+
+note bottom of oldList
+  既存データは共有され
+  コピーされない
+end note
+@enduml
+```
+
+## 3. データ変換パイプライン
+
+関数型プログラミングでは、データを変換する一連の処理を**パイプライン**として表現します。Elixir ではパイプ演算子 `|>` を使用して、読みやすいパイプラインを構築できます。
+
+### 実践例：注文処理システム
+
+```elixir
+defmodule Item do
+  defstruct [:name, :price, :quantity]
+end
+
+defmodule Customer do
+  defstruct [:name, :membership]
+end
+
+defmodule Order do
+  defstruct [:items, :customer]
+end
+
+# 各アイテムの小計を計算
+def calculate_subtotal(%Item{price: price, quantity: quantity}) do
+  price * quantity
+end
+
+# 会員種別に応じた割引率を取得
+def membership_discount(membership) do
+  case membership do
+    "gold"   -> 0.1
+    "silver" -> 0.05
+    "bronze" -> 0.02
+    _        -> 0.0
+  end
+end
+
+# 注文の合計金額を計算
+def calculate_total(items) do
+  items
+  |> Enum.map(&calculate_subtotal/1)
+  |> Enum.sum()
+end
+
+# 割引を適用した金額を計算
+def apply_discount(total, membership) do
+  discount_rate = membership_discount(membership)
+  total * (1 - discount_rate)
+end
+
+# 注文を処理し、割引後の合計金額を返す
+def process_order(%Order{items: items, customer: customer}) do
+  items
+  |> calculate_total()
+  |> apply_discount(customer.membership)
+end
+```
+
+### Elixir のパイプ演算子
+
+パイプ演算子 `|>` は、左側の式の結果を右側の関数の第一引数として渡します：
+
+```elixir
+# パイプ演算子を使用
+items
+|> Enum.map(&calculate_subtotal/1)
+|> Enum.sum()
+
+# 上記と同等の入れ子呼び出し
+Enum.sum(Enum.map(items, &calculate_subtotal/1))
+```
+
+パイプ演算子を使うと、データの流れが上から下へと明確になり、可読性が向上します。
+
+## 4. 副作用の分離
+
+関数型プログラミングでは、**純粋関数**と**副作用を持つ関数**を明確に分離することが重要です。
+
+### 純粋関数とは
+
+- 同じ入力に対して常に同じ出力を返す
+- 外部の状態を変更しない（副作用がない）
+
+```elixir
+# 純粋関数
+def calculate_tax(amount, tax_rate) do
+  amount * tax_rate
+end
+
+# 何度呼んでも同じ結果
+calculate_tax(1000, 0.1)  # => 100.0
+calculate_tax(1000, 0.1)  # => 100.0
+```
+
+### 副作用の分離パターン
+
+ビジネスロジック（純粋関数）と副作用（I/O）を分離します：
+
+```elixir
+defmodule Invoice do
+  defstruct [:subtotal, :tax, :total]
+end
+
+# ビジネスロジック（純粋関数）
+def calculate_invoice(items, tax_rate) do
+  subtotal = calculate_total(items)
+  tax = calculate_tax(subtotal, tax_rate)
+  total = subtotal + tax
+  %Invoice{subtotal: subtotal, tax: tax, total: total}
+end
+
+# 副作用を含む処理（分離）
+def save_invoice(%Invoice{} = invoice) do
+  # データベースへの保存（副作用）
+  IO.puts("Saving invoice: #{inspect(invoice)}")
+  invoice
+end
+
+def send_notification(%Invoice{} = invoice, customer_email) do
+  # メール送信（副作用）
+  IO.puts("Sending notification to: #{customer_email}")
+  invoice
+end
+
+# 処理全体のオーケストレーション
+def process_and_save_invoice(items, tax_rate, customer_email) do
+  items
+  |> calculate_invoice(tax_rate)
+  |> save_invoice()
+  |> send_notification(customer_email)
+end
+```
+
+Elixir では慣例的に副作用を持つ関数に `!` サフィックスを付けることがあります（例：`File.read!`）。
+
+## 5. 永続的データ構造の活用：Undo/Redo の実装
+
+不変データ構造を活用すると、履歴管理が非常に簡単に実装できます。
+
+```elixir
+defmodule History do
+  defstruct current: nil, past: [], future: []
+end
+
+# 空の履歴を作成
+def create_history, do: %History{}
+
+# 新しい状態を履歴にプッシュ
+def push_state(%History{current: nil} = history, new_state) do
+  %{history | current: new_state}
+end
+
+def push_state(%History{current: current, past: past} = history, new_state) do
+  %{history | current: new_state, past: [current | past], future: []}
+end
+
+# 直前の状態に戻す（Undo）
+def undo(%History{past: []} = history), do: history
+
+def undo(%History{current: current, past: [previous | rest], future: future}) do
+  %History{current: previous, past: rest, future: [current | future]}
+end
+
+# やり直し操作（Redo）
+def redo(%History{future: []} = history), do: history
+
+def redo(%History{current: current, past: past, future: [next | rest]}) do
+  %History{current: next, past: [current | past], future: rest}
+end
+```
+
+### 使用例
+
+```elixir
+history =
+  create_history()
+  |> push_state(%{text: "Hello"})
+  |> push_state(%{text: "Hello World"})
+  |> push_state(%{text: "Hello World!"})
+
+history.current  # => %{text: "Hello World!"}
+
+after_undo = undo(history)
+after_undo.current  # => %{text: "Hello World"}
+
+after_redo = redo(after_undo)
+after_redo.current  # => %{text: "Hello World!"}
+```
+
+## 6. Stream による遅延評価
+
+複数の変換を行う場合、通常の `Enum` では中間リストが作成されます。Elixir では **Stream** を使用すると、複数の変換を1回のパスで処理できます。
+
+```elixir
+# 通常の Enum 処理（中間リストが作成される）
+def process_items(items) do
+  items
+  |> Enum.filter(&(&1.quantity > 0))
+  |> Enum.map(fn item ->
+    %ProcessedItem{
+      name: item.name,
+      price: item.price,
+      quantity: item.quantity,
+      subtotal: calculate_subtotal(item)
+    }
+  end)
+  |> Enum.filter(&(&1.subtotal > 100))
+end
+
+# Stream を使用した遅延評価（中間リストを作成しない）
+def process_items_lazy(items) do
+  items
+  |> Stream.filter(&(&1.quantity > 0))
+  |> Stream.map(fn item ->
+    %ProcessedItem{
+      name: item.name,
+      price: item.price,
+      quantity: item.quantity,
+      subtotal: calculate_subtotal(item)
+    }
+  end)
+  |> Stream.filter(&(&1.subtotal > 100))
+  |> Enum.to_list()
+end
+```
+
+Stream の利点：
+- 中間リストを作成しない
+- 遅延評価により必要な要素のみ処理
+- メモリ効率が良い
+
+### 無限ストリーム
+
+Stream は無限シーケンスも扱えます：
+
+```elixir
+def take_even_numbers(count) do
+  Stream.iterate(1, &(&1 + 1))
+  |> Stream.filter(&(rem(&1, 2) == 0))
+  |> Enum.take(count)
+end
+
+take_even_numbers(5)  # => [2, 4, 6, 8, 10]
+```
+
+## 7. ネストしたデータの操作
+
+Elixir には `get_in`、`put_in`、`update_in` というマクロがあり、ネストしたデータ構造を簡潔に操作できます。
+
+```elixir
+data = %{user: %{profile: %{name: "田中", age: 30}}}
+
+# ネストした値の取得
+get_in(data, [:user, :profile, :name])  # => "田中"
+
+# ネストした値の更新（新しいマップを返す）
+put_in(data, [:user, :profile, :name], "鈴木")
+# => %{user: %{profile: %{name: "鈴木", age: 30}}}
+
+# ネストした値を関数で更新
+update_in(data, [:user, :profile, :age], &(&1 + 1))
+# => %{user: %{profile: %{name: "田中", age: 31}}}
+
+# 元のデータは変更されない
+data  # => %{user: %{profile: %{name: "田中", age: 30}}}
+```
+
+## まとめ
+
+本章では、関数型プログラミングの基礎である不変性について学びました：
+
+1. **不変データ構造**: 構造体と `%{struct | key: value}` による不変性の実現
+2. **構造共有**: 効率的なメモリ使用を実現する永続的データ構造
+3. **パイプ演算子**: `|>` による読みやすいデータ変換パイプライン
+4. **副作用の分離**: 純粋関数と I/O 処理の明確な分離
+5. **履歴管理**: 不変性を活用した Undo/Redo の簡潔な実装
+6. **Stream**: 効率的な遅延評価による複合変換
+7. **ネストした操作**: `get_in`/`put_in`/`update_in` による簡潔な操作
+
+これらの概念は、関数型プログラミングの他のすべてのパターンの基盤となります。
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/elixir/part1/lib/chapter01.ex`
+- テストコード: `apps/elixir/part1/test/chapter01_test.exs`
+
+## 次章予告
+
+次章では、**関数合成と高階関数**について学びます。小さな関数を組み合わせて複雑な処理を構築する方法を探ります。