@k2works/claude-code-booster 6.2.0 → 6.3.0

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

@@ -1,241 +0,0 @@
-# 関数型デザイン - 原則、パターン、実践
-
-## はじめに
-
-本記事シリーズは、関数型プログラミングにおける設計原則とデザインパターンを実践的に学ぶためのガイドです。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)
-
-
-    - 既存コードのリファクタリング戦略
-    - 段階的な移行アプローチ
-    - 共存と統合
-
----
-
-## 付録
-
-- 用語集（未作成）
-- 参考文献（未作成）
-- Clojure 開発環境セットアップ（未作成）
-
----
-
-## 本シリーズの特徴
-
-### 実践重視
-
-すべてのパターンは実際に動作するコード例を含みます。理論だけでなく、実装を通じて理解を深めることを重視しています。
-
-### テスト駆動
-
-各パターンの実装にはテストコードが付属しています。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

@@ -1,392 +0,0 @@
----
-type: Article
-title: "第1章: 不変性とデータ変換"
-description: "関数型プログラミングの最も重要な概念の一つが不変性（Immutability）です。"
-tags: [article, functional-desgin-ppp, elixir]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-27T04:43:33Z }
----
-
-# 第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`
-
-## 次章予告
-
-次章では、**関数合成と高階関数**について学びます。小さな関数を組み合わせて複雑な処理を構築する方法を探ります。