@k2works/claude-code-booster 3.0.0 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/all/20-pattern-interactions.md

@@ -0,0 +1,274 @@
+# 第20章: パターン間の相互作用 — 6言語統合ガイド
+
+## 1. はじめに
+
+個々のデザインパターンを学んだ後、次のステップは**パターンを組み合わせて**より高度な設計を実現することです。Composite + Decorator、Command + Observer、Strategy + Factory — これらの組み合わせにより、単一のパターンでは達成できない柔軟性と表現力を得られます。
+
+## 2. 共通の本質
+
+### パターン組み合わせの原則
+
+| 組み合わせ | 効果 |
+|-----------|------|
+| Composite + Decorator | 階層構造への動的な機能追加 |
+| Command + Observer | 操作の実行と監視・通知の統合 |
+| Strategy + Factory | 条件に基づく戦略の自動選択 |
+
+すべての組み合わせは**関心の分離**と**合成可能性**を実現します。
+
+## 3. 言語別実装比較
+
+### 3.1 Composite + Decorator
+
+階層的なデータ構造（Composite）に、ロギングやスタイリングなどの横断的関心事（Decorator）を追加するパターンです。
+
+<details>
+<summary>Clojure: マルチメソッド + 高階関数</summary>
+
+```clojure
+;; Composite: 再帰的な図形構造
+(defmulti area :type)
+(defmethod area :circle [{:keys [radius]}]
+  (* Math/PI radius radius))
+(defmethod area :composite [{:keys [children]}]
+  (reduce + (map area children)))
+
+;; Decorator: ロギングを追加
+(defn with-logging [shape-fn]
+  (fn [shape]
+    (let [result (shape-fn shape)]
+      (println (str "Area of " (:type shape) ": " result))
+      result)))
+
+;; 組み合わせ
+(def logged-area (with-logging area))
+(logged-area composite-shape)
+```
+
+</details>
+
+<details>
+<summary>Scala: case class + 拡張メソッド</summary>
+
+```scala
+// Composite
+sealed trait Shape:
+  def area: Double
+
+case class Circle(radius: Double) extends Shape:
+  def area: Double = math.Pi * radius * radius
+
+case class CompositeShape(children: Vector[Shape]) extends Shape:
+  def area: Double = children.map(_.area).sum
+
+// Decorator: スタイル付き図形
+case class StyledShape(shape: Shape, style: Style) extends Shape:
+  def area: Double = shape.area
+
+// 組み合わせ
+val styled = StyledShape(
+  CompositeShape(Vector(Circle(5), Circle(3))),
+  Style(color = "red", outline = true)
+)
+```
+
+</details>
+
+<details>
+<summary>Haskell: ADT + 関数合成</summary>
+
+```haskell
+-- Composite + Decorator を ADT で統合
+data Shape
+    = Circle Double
+    | Square Double
+    | Composite [Shape]
+    | Styled Style Shape    -- Decorator を型として表現
+
+area :: Shape -> Double
+area (Circle r)      = pi * r * r
+area (Square s)      = s * s
+area (Composite ss)  = sum (map area ss)
+area (Styled _ s)    = area s  -- スタイルは面積に影響しない
+
+-- 関数合成でデコレータを適用
+withLogging :: (Shape -> Double) -> Shape -> IO Double
+withLogging f shape = do
+    let result = f shape
+    putStrLn $ "Area: " ++ show result
+    return result
+```
+
+</details>
+
+<details>
+<summary>Rust: enum + trait</summary>
+
+```rust
+pub enum Shape {
+    Circle { radius: f64 },
+    Composite { shapes: Vec<Shape> },
+    Styled { shape: Box<Shape>, style: Style },
+}
+
+impl Shape {
+    pub fn area(&self) -> f64 {
+        match self {
+            Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
+            Shape::Composite { shapes } => shapes.iter().map(|s| s.area()).sum(),
+            Shape::Styled { shape, .. } => shape.area(),
+        }
+    }
+}
+```
+
+</details>
+
+### 3.2 Command + Observer
+
+コマンドの実行を Observer が監視し、Undo/Redo の履歴管理と変更通知を統合するパターンです。
+
+<details>
+<summary>Clojure: atom + watch</summary>
+
+```clojure
+;; Command 履歴の管理
+(def history (atom {:undo-stack [] :redo-stack [] :document ""}))
+
+;; Observer: 状態変更を監視
+(add-watch history :logger
+  (fn [_ _ old-state new-state]
+    (println "Document changed:"
+             (:document old-state) " -> " (:document new-state))))
+
+;; Command 実行 + 自動通知
+(defn execute-command [cmd]
+  (swap! history
+    (fn [state]
+      (-> state
+          (update :undo-stack conj cmd)
+          (assoc :redo-stack [])
+          (update :document (execute cmd))))))
+```
+
+</details>
+
+<details>
+<summary>F#: イベント + パイプライン</summary>
+
+```fsharp
+type CommandEvent =
+    | Executed of command: TextCommand * document: string
+    | Undone of command: TextCommand * document: string
+
+type CommandProcessor = {
+    Document: string
+    History: TextCommand list
+    Listeners: (CommandEvent -> unit) list
+}
+
+let executeCommand (cmd: TextCommand) (processor: CommandProcessor) =
+    let newDoc = TextCommand.execute cmd processor.Document
+    let event = Executed(cmd, newDoc)
+    processor.Listeners |> List.iter (fun listener -> listener event)
+    { processor with
+        Document = newDoc
+        History = cmd :: processor.History }
+```
+
+</details>
+
+### 3.3 Strategy + Factory
+
+条件に基づいて適切な Strategy を自動選択する Factory パターンです。
+
+<details>
+<summary>全言語のStrategy + Factory比較</summary>
+
+```clojure
+;; Clojure: マップベースのファクトリ
+(def strategy-factory
+  {:regular  regular-pricing
+   :member   member-pricing
+   :vip      (discount-pricing 0.3)
+   :bulk     (bulk-pricing 10000 0.15)})
+
+(defn get-strategy [customer-type]
+  (get strategy-factory customer-type regular-pricing))
+```
+
+```scala
+// Scala: パターンマッチ + 関数リテラル
+def createStrategy(customerType: CustomerType): PricingFn =
+  customerType match
+    case Regular => identity
+    case Member  => _ * 0.9
+    case VIP     => _ * 0.7
+
+// Factory でコンテキストに基づき自動選択
+def autoPricing(customer: Customer, amount: Double): Double =
+  createStrategy(customer.customerType)(amount)
+```
+
+```haskell
+-- Haskell: 関数の直接返却
+createStrategy :: CustomerType -> PricingStrategy
+createStrategy Regular = regularPricing
+createStrategy Member  = memberPricing
+createStrategy VIP     = discountPricing 0.3
+```
+
+```rust
+// Rust: match + クロージャ
+pub fn create_strategy(customer_type: &CustomerType) -> Box<dyn Fn(f64) -> f64> {
+    match customer_type {
+        CustomerType::Regular => Box::new(|amount| amount),
+        CustomerType::Member => Box::new(|amount| amount * 0.9),
+        CustomerType::VIP => Box::new(|amount| amount * 0.7),
+    }
+}
+```
+
+</details>
+
+## 4. 比較分析
+
+### 4.1 パターン合成の容易さ
+
+| 言語 | 合成の仕組み | 特徴 |
+|------|-----------|------|
+| Clojure | 関数合成 + マルチメソッド | 最も動的で柔軟 |
+| Scala | trait 継承 + パターンマッチ | OOP と FP のハイブリッド |
+| Elixir | パイプライン + プロトコル | 可読性の高い合成 |
+| F# | パイプ演算子 + 判別共用体 | 型安全な合成 |
+| Haskell | 関数合成 `(.)` + ADT | 最も数学的な合成 |
+| Rust | trait + enum + クロージャ | 所有権を考慮した合成 |
+
+### 4.2 組み合わせの安全性
+
+パターンを組み合わせる際、静的型付け言語はコンパイル時に整合性を検証できます：
+
+- **Haskell, F#**: ADT / 判別共用体の網羅性チェック
+- **Scala, Rust**: sealed trait / enum の網羅性チェック
+- **Clojure, Elixir**: テストで整合性を確認
+
+## 5. 実践的な選択指針
+
+| 組み合わせ | 推奨言語 | 理由 |
+|-----------|---------|------|
+| Composite + Decorator | Haskell | ADT で両パターンを型として統合 |
+| Command + Observer | Clojure | atom + watch で自然に統合 |
+| Strategy + Factory | Scala | パターンマッチで簡潔に選択 |
+| 全般的な合成 | F# | パイプ演算子で可読性の高い合成 |
+
+## 6. まとめ
+
+パターン間の相互作用は、関数型プログラミングの**合成可能性**を最大限に活かす実践です：
+
+1. **関数合成がパターン合成**: 高階関数でパターンを組み合わせ
+2. **ADT が構造を統合**: Composite と Decorator を同じ型階層で表現
+3. **イベント駆動が連携を実現**: Command の実行が Observer に自動通知
+
+## 言語別個別記事
+
+- [Clojure](../clojure/20-pattern-interactions.md) | [Scala](../scala/20-pattern-interactions.md) | [Elixir](../elixir/20-pattern-interactions.md) | [F#](../fsharp/20-pattern-interactions.md) | [Haskell](../haskell/20-pattern-interactions.md) | [Rust](../rust/20-pattern-interactions.md)

package/lib/assets/docs/article/functional-desgin-ppp/all/21-best-practices.md

@@ -0,0 +1,294 @@
+# 第21章: ベストプラクティス — 6言語統合ガイド
+
+## 1. はじめに
+
+本章は、これまでの 20 章で学んだ関数型デザインパターンを実践で活かすための**ベストプラクティス**をまとめます。6 言語に共通する原則と、各言語固有のイディオムを整理し、「よいソフトウェア」を関数型で実現するための指針を提供します。
+
+## 2. 共通の原則
+
+### 2.1 データ中心設計
+
+すべての言語で共通する最も重要な原則です。
+
+```
+1. まずデータ構造を定義する
+2. データを変換する関数を書く
+3. 関数をパイプラインで合成する
+```
+
+| 言語 | データ定義 | 変換 | 合成 |
+|------|----------|------|------|
+| Clojure | マップ | 関数 | `->` / `->>` |
+| Scala | case class | メソッド / 関数 | `map` / `flatMap` |
+| Elixir | 構造体 | 関数 | `\|>` |
+| F# | レコード | 関数 | `\|>` |
+| Haskell | data / newtype | 関数 | `.` / `$` |
+| Rust | struct | impl / 関数 | メソッドチェーン / `iter()` |
+
+### 2.2 純粋関数の優先
+
+```
+純粋関数 = 同じ入力に対して常に同じ出力を返し、副作用がない
+```
+
+<details>
+<summary>純粋関数 vs 非純粋関数の例</summary>
+
+```clojure
+;; 純粋（テスト容易）
+(defn calculate-total [items tax-rate]
+  (* (reduce + (map :price items)) (+ 1 tax-rate)))
+
+;; 非純粋（テスト困難）
+(defn calculate-total-impure [items]
+  (let [tax-rate (fetch-tax-rate!)  ;; 副作用
+        total (* (reduce + (map :price items)) (+ 1 tax-rate))]
+    (save-to-db! total)              ;; 副作用
+    total))
+```
+
+```haskell
+-- 純粋
+calculateTotal :: [Item] -> Double -> Double
+calculateTotal items taxRate = sum (map itemPrice items) * (1 + taxRate)
+
+-- 副作用は型で明示
+calculateTotalIO :: [Item] -> IO Double
+calculateTotalIO items = do
+    taxRate <- fetchTaxRate
+    let total = sum (map itemPrice items) * (1 + taxRate)
+    saveToDB total
+    return total
+```
+
+</details>
+
+### 2.3 副作用の分離（Functional Core / Imperative Shell）
+
+```
+Functional Core:  純粋なビジネスロジック（テスト容易）
+Imperative Shell: I/O・DB・外部 API（薄いレイヤー）
+```
+
+| 言語 | Core の表現 | Shell の表現 |
+|------|-----------|-------------|
+| Clojure | 純粋関数 | atom / Agent / I/O |
+| Scala | 純粋関数 / IO モナド | Future / Side effects |
+| Elixir | 純粋関数 | GenServer / Agent |
+| F# | 純粋関数 | Async / Task |
+| Haskell | 純粋関数 | IO モナド |
+| Rust | 純粋関数 | `Result<T, E>` / I/O |
+
+### 2.4 テスト可能性の設計
+
+<details>
+<summary>依存性注入による副作用の分離</summary>
+
+```clojure
+;; Clojure: 関数を引数として渡す
+(defn process-order [order fetch-price save-order]
+  (let [total (reduce + (map #(fetch-price (:product-id %)) (:items order)))]
+    (save-order (assoc order :total total))))
+
+;; テスト
+(deftest test-process-order
+  (let [mock-fetch (constantly 100)
+        mock-save identity]
+    (is (= 200 (:total (process-order order mock-fetch mock-save))))))
+```
+
+```rust
+// Rust: trait bounds で抽象化
+pub fn process_order<P, S>(order: &Order, pricer: P, saver: S) -> Result<Order, String>
+where
+    P: Fn(&str) -> f64,
+    S: Fn(&Order) -> Result<(), String>,
+{
+    let total: f64 = order.items.iter().map(|i| pricer(&i.product_id)).sum();
+    let updated = Order { total, ..order.clone() };
+    saver(&updated)?;
+    Ok(updated)
+}
+```
+
+```haskell
+-- Haskell: 型クラスで抽象化
+class Monad m => OrderProcessor m where
+    fetchPrice :: ProductId -> m Double
+    saveOrder  :: Order -> m ()
+
+processOrder :: OrderProcessor m => Order -> m Order
+processOrder order = do
+    prices <- mapM (fetchPrice . productId) (items order)
+    let total = sum prices
+    let updated = order { orderTotal = total }
+    saveOrder updated
+    return updated
+```
+
+</details>
+
+### 2.5 エラーハンドリング
+
+| 言語 | 成功/失敗の型 | チェーン方法 |
+|------|-----------|-----------|
+| Clojure | `nil` / 例外 / `{:ok v}` | `some->` / `try-catch` |
+| Scala | `Either[E, A]` / `Option[A]` | `flatMap` / `for` |
+| Elixir | `{:ok, v}` / `{:error, e}` | `with` 式 |
+| F# | `Result<'T, 'E>` / `Option<'T>` | `Result.bind` / パイプ |
+| Haskell | `Either e a` / `Maybe a` | `>>=` / `do` 記法 |
+| Rust | `Result<T, E>` / `Option<T>` | `?` 演算子 / `and_then` |
+
+## 3. 言語固有のイディオム
+
+### 3.1 Clojure: データリテラルとプロトコル
+
+```clojure
+;; データリテラルで直接表現
+(def config
+  {:db {:host "localhost" :port 5432}
+   :cache {:ttl 3600}})
+
+;; プロトコルで既存データに振る舞いを追加
+(defprotocol Cacheable
+  (cache-key [this])
+  (ttl [this]))
+
+(extend-type clojure.lang.PersistentHashMap
+  Cacheable
+  (cache-key [m] (hash m))
+  (ttl [_] 3600))
+```
+
+### 3.2 Scala: given/using と型クラス
+
+```scala
+// コンテキストの自動提供
+given Ordering[Product] with
+  def compare(a: Product, b: Product): Int =
+    a.price.compareTo(b.price)
+
+def cheapest(products: List[Product])(using ord: Ordering[Product]): Product =
+  products.min
+```
+
+### 3.3 Elixir: パイプラインと Stream
+
+```elixir
+# パイプラインで処理フローを明確に
+result =
+  data
+  |> validate()
+  |> transform()
+  |> Enum.filter(&active?/1)
+  |> Enum.map(&format/1)
+
+# Stream で遅延評価
+large_file
+|> File.stream!()
+|> Stream.map(&String.trim/1)
+|> Stream.filter(&(&1 != ""))
+|> Enum.take(100)
+```
+
+### 3.4 F#: パイプ演算子と計算式
+
+```fsharp
+// パイプ演算子で左から右へ
+let result =
+    data
+    |> validate
+    |> transform
+    |> List.filter isActive
+    |> List.map format
+
+// 計算式で Result チェーン
+let processOrder order = result {
+    let! validated = validateOrder order
+    let! priced = calculatePrice validated
+    let! saved = saveOrder priced
+    return saved
+}
+```
+
+### 3.5 Haskell: newtype とプロパティテスト
+
+```haskell
+-- newtype でドメインプリミティブ
+newtype Email = Email String
+newtype UserId = UserId Int
+
+-- 型クラスでプロパティを保証
+prop_serializeRoundTrip :: User -> Bool
+prop_serializeRoundTrip user =
+    deserialize (serialize user) == Just user
+```
+
+### 3.6 Rust: 所有権とイテレータ
+
+```rust
+// 所有権を活かしたビルダーパターン
+let order = OrderBuilder::new()
+    .customer("Alice")
+    .add_item(item1)
+    .add_item(item2)
+    .build()?;
+
+// イテレータチェーンで効率的な処理
+let total: f64 = orders
+    .iter()
+    .filter(|o| o.status == Status::Completed)
+    .flat_map(|o| o.items.iter())
+    .map(|i| i.price)
+    .sum();
+```
+
+## 4. 比較分析
+
+### 4.1 副作用分離の厳密さ
+
+```
+厳密 ←――――――――――――――――――→ 柔軟
+
+Haskell    F#    Rust    Scala    Elixir    Clojure
+├─IO モナド┤     │       │        │         │
+           ├─CE──┤       │        │         │
+                 ├─型──┤         │         │
+                        ├─Effect─┤         │
+                                  ├─Agent──┤
+                                            ├─規約
+```
+
+### 4.2 コードの表現力
+
+| 基準 | 最も表現力が高い | 理由 |
+|------|----------------|------|
+| データ変換パイプライン | Elixir / F# | `\|>` が最も直感的 |
+| 型レベルの安全性 | Haskell | newtype + 型クラスで不正状態を排除 |
+| 実用的なバランス | Scala / F# | OOP との調和 + 型安全性 |
+| 動的な柔軟性 | Clojure | マップリテラルの自由度 |
+| メモリ効率 | Rust | ゼロコスト抽象化 |
+
+## 5. 実践的な選択指針
+
+| プロジェクト特性 | 推奨アプローチ | 推奨言語 |
+|---------------|-------------|---------|
+| 高い信頼性が必要 | 純粋関数 + 型安全性 | Haskell, F# |
+| 高い並行性が必要 | アクターモデル + 不変性 | Elixir, Scala |
+| パフォーマンスが最重要 | ゼロコスト抽象化 | Rust |
+| プロトタイピング | データリテラル + REPL | Clojure |
+| エンタープライズ | マルチパラダイム | Scala, F# |
+
+## 6. まとめ
+
+関数型ベストプラクティスの核心は 3 つの原則に集約されます：
+
+1. **データ中心**: まずデータ構造を定義し、次に変換関数を書く
+2. **純粋性**: 副作用を分離し、ビジネスロジックを純粋関数で表現する
+3. **合成可能性**: 小さな関数を合成して大きな機能を構築する
+
+これらの原則はすべての関数型言語に共通であり、言語が変わっても**考え方**は同じです。
+
+## 言語別個別記事
+
+- [Clojure](../clojure/21-best-practices.md) | [Scala](../scala/21-best-practices.md) | [Elixir](../elixir/21-best-practices.md) | [F#](../fsharp/21-best-practices.md) | [Haskell](../haskell/21-best-practices.md) | [Rust](../rust/21-best-practices.md)