@k2works/claude-code-booster 6.2.0 → 6.3.1

package/lib/assets/docs/article/functional-desgin-ppp/all/07-composite-pattern.md

@@ -1,307 +0,0 @@
----
-type: Article
-title: "第7章: Composite パターン — 6言語統合ガイド"
-description: "Composite パターンは、個別のオブジェクトと複合オブジェクトを同一のインターフェースで扱う GoF パターンです。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第7章: Composite パターン — 6言語統合ガイド
-
-## 1. はじめに
-
-Composite パターンは、個別のオブジェクトと複合オブジェクトを同一のインターフェースで扱う GoF パターンです。関数型プログラミングでは、**再帰的なデータ型（ADT / 判別共用体 / enum）**がこのパターンを自然に表現します。ツリー構造のデータに対する操作が、パターンマッチと再帰で簡潔に記述できます。
-
-> **Elixir の読者へ**: Elixir 版は本章で「副作用と純粋関数」を扱っています。Elixir 固有のアプローチについては[コラム](#elixir-コラム副作用と純粋関数)を参照してください。
-
-## 2. 共通の本質
-
-### Composite の構造
-
-```
-Shape = Circle radius
-      | Square side
-      | Composite [Shape]    ← 再帰的な定義
-```
-
-- **Leaf（葉）**: 個別の要素（Circle, Square）
-- **Composite（複合）**: 子要素のリストを持つノード
-- **統一インターフェース**: Leaf と Composite を同じ関数で処理
-
-### 典型的な操作
-
-- **面積計算**: 各図形の面積を再帰的に合計
-- **移動（translate）**: すべての要素を一括移動
-- **バウンディングボックス**: 複合図形の外接矩形を計算
-
-## 3. 言語別実装比較
-
-### 3.1 再帰的データ型の定義
-
-| 言語 | 型定義 | 再帰の表現 |
-|------|--------|----------|
-| Clojure | マップ + `::type` キー | `:children` リスト |
-| Scala | `sealed trait` + `case class` | `children: Vector[Shape]` |
-| F# | 判別共用体 | `Composite of Shape list` |
-| Haskell | ADT | `CompositeShape [Shape]` |
-| Rust | `enum` | `Composite { shapes: Vec<Shape> }` |
-
-<details>
-<summary>Haskell: ADT による再帰的定義</summary>
-
-```haskell
-data Shape
-    = Circle Point Double
-    | Square Point Double
-    | Rectangle Point Double Double
-    | CompositeShape [Shape]
-
-area :: Shape -> Double
-area shape = case shape of
-    Circle _ r        -> pi * r * r
-    Square _ s        -> s * s
-    Rectangle _ w h   -> w * h
-    CompositeShape ss -> sum (map area ss)
-```
-
-`CompositeShape [Shape]` が再帰的な定義のポイントです。`area` 関数は `map area` で子要素に再帰適用します。
-
-</details>
-
-<details>
-<summary>Scala: sealed trait + パターンマッチ</summary>
-
-```scala
-sealed trait Shape
-case class Circle(center: Point, radius: Double) extends Shape
-case class Square(topLeft: Point, side: Double) extends Shape
-case class CompositeShape(children: Vector[Shape]) extends Shape
-
-def area(shape: Shape): Double = shape match
-  case Circle(_, r)          => math.Pi * r * r
-  case Square(_, s)          => s * s
-  case CompositeShape(children) => children.map(area).sum
-```
-
-</details>
-
-<details>
-<summary>F#: 判別共用体</summary>
-
-```fsharp
-type Shape =
-    | Circle of center: Point * radius: float
-    | Square of topLeft: Point * side: float
-    | Composite of name: string * shapes: Shape list
-
-let rec area (shape: Shape) : float =
-    match shape with
-    | Circle(_, r) -> System.Math.PI * r * r
-    | Square(_, s) -> s * s
-    | Composite(_, shapes) -> shapes |> List.sumBy area
-```
-
-`rec` キーワードで再帰関数を明示します。`List.sumBy` で簡潔に合計を計算できます。
-
-</details>
-
-<details>
-<summary>Rust: enum + Box</summary>
-
-```rust
-pub enum Shape {
-    Circle { center: Point, radius: f64 },
-    Square { top_left: Point, side: f64 },
-    Composite { shapes: Vec<Shape> },
-}
-
-impl Shape {
-    pub fn area(&self) -> f64 {
-        match self {
-            Shape::Circle { radius, .. } =>
-                std::f64::consts::PI * radius * radius,
-            Shape::Square { side, .. } => side * side,
-            Shape::Composite { shapes } =>
-                shapes.iter().map(|s| s.area()).sum(),
-        }
-    }
-}
-```
-
-Rust では `Vec<Shape>` で所有権を持つ子要素リストを表現します。
-
-</details>
-
-<details>
-<summary>Clojure: マップ + マルチメソッド</summary>
-
-```clojure
-(defn make-circle [center radius]
-  {::type ::circle ::center center ::radius radius})
-
-(defn make-composite [& shapes]
-  {::type ::composite ::children (vec shapes)})
-
-(defmulti area ::type)
-(defmethod area ::circle [{:keys [radius]}]
-  (* Math/PI radius radius))
-(defmethod area ::square [{:keys [side]}]
-  (* side side))
-(defmethod area ::composite [{:keys [children]}]
-  (reduce + (map area children)))
-```
-
-</details>
-
-### 3.2 移動（translate）操作
-
-複合図形全体を移動する操作は、Composite パターンの典型的な活用例です。
-
-<details>
-<summary>translate の実装比較</summary>
-
-```haskell
--- Haskell
-translate :: Double -> Double -> Shape -> Shape
-translate dx dy shape = case shape of
-    Circle (Point x y) r -> Circle (Point (x+dx) (y+dy)) r
-    Square (Point x y) s -> Square (Point (x+dx) (y+dy)) s
-    CompositeShape ss    -> CompositeShape (map (translate dx dy) ss)
-```
-
-```scala
-// Scala
-def translate(dx: Double, dy: Double)(shape: Shape): Shape = shape match
-  case Circle(Point(x, y), r) => Circle(Point(x+dx, y+dy), r)
-  case Square(Point(x, y), s) => Square(Point(x+dx, y+dy), s)
-  case CompositeShape(cs)     => CompositeShape(cs.map(translate(dx, dy)))
-```
-
-```rust
-// Rust
-pub fn translate(&self, dx: f64, dy: f64) -> Shape {
-    match self {
-        Shape::Circle { center, radius } =>
-            Shape::Circle {
-                center: Point { x: center.x + dx, y: center.y + dy },
-                radius: *radius,
-            },
-        Shape::Composite { shapes } =>
-            Shape::Composite {
-                shapes: shapes.iter().map(|s| s.translate(dx, dy)).collect(),
-            },
-        // ...
-    }
-}
-```
-
-</details>
-
-すべての言語で、Composite ケースは**子要素に対して同じ関数を再帰適用**する同じパターンです。
-
-### 3.3 flatten（ネスト構造の平坦化）
-
-<details>
-<summary>ネスト構造の平坦化</summary>
-
-```scala
-// Scala
-def flatten(shape: Shape): Vector[Shape] = shape match
-  case CompositeShape(children) => children.flatMap(flatten)
-  case leaf                     => Vector(leaf)
-```
-
-```haskell
--- Haskell
-flatten :: Shape -> [Shape]
-flatten (CompositeShape ss) = concatMap flatten ss
-flatten leaf                = [leaf]
-```
-
-```fsharp
-// F#
-let rec flatten (shape: Shape) : Shape list =
-    match shape with
-    | Composite(_, shapes) -> shapes |> List.collect flatten
-    | leaf -> [leaf]
-```
-
-</details>
-
-## 4. 比較分析
-
-### 4.1 再帰的データ型の表現力
-
-| 言語 | 型安全性 | ネストの深さ制限 | メモリ管理 |
-|------|---------|----------------|----------|
-| Clojure | なし（動的） | なし | GC（JVM） |
-| Scala | sealed で網羅性保証 | なし | GC（JVM） |
-| F# | 判別共用体で網羅性保証 | なし | GC（.NET） |
-| Haskell | ADT で網羅性保証 | なし（遅延評価） | GC（GHC） |
-| Rust | enum で網羅性保証 | `Vec` で所有権管理 | 所有権システム |
-
-### 4.2 OOP Composite vs 関数型 Composite
-
-| 観点 | OOP | 関数型 |
-|------|-----|--------|
-| 型定義 | インターフェース + クラス階層 | ADT / 判別共用体 / enum |
-| 操作追加 | 各クラスにメソッド追加 | 新しい関数を定義 |
-| データ構造 | ミュータブルな子リスト | 不変の再帰構造 |
-| 操作の統一性 | `accept` メソッド | パターンマッチ |
-
-## 5. Elixir コラム：副作用と純粋関数
-
-Elixir の第 7 章は Composite パターンではなく、**副作用と純粋関数の分離**を扱っています。
-
-### Functional Core / Imperative Shell
-
-```elixir
-# 純粋関数（テスト容易）
-defmodule PriceCalculator do
-  def calculate(items, tax_rate) do
-    subtotal = Enum.sum(Enum.map(items, & &1.price))
-    subtotal * (1 + tax_rate)
-  end
-end
-
-# 副作用を含むシェル
-defmodule OrderService do
-  def process_order(order_id) do
-    items = Repo.get_items(order_id)        # I/O
-    total = PriceCalculator.calculate(items, 0.1)  # 純粋
-    Repo.save_total(order_id, total)        # I/O
-  end
-end
-```
-
-### Effect as Data
-
-副作用をデータとして表現し、実行を遅延させるパターンです：
-
-```elixir
-defmodule Effects do
-  def log(message), do: {:log, message}
-  def save(data), do: {:save, data}
-  def fetch(id), do: {:fetch, id}
-end
-
-# 効果を解釈する
-def interpret({:log, msg}), do: IO.puts(msg)
-def interpret({:save, data}), do: Repo.save(data)
-def interpret({:fetch, id}), do: Repo.get(id)
-```
-
-このアプローチは Haskell の IO モナドと同じ発想であり、「何をするか」と「どう実行するか」を分離します。
-
-## 6. まとめ
-
-Composite パターンは、関数型プログラミングの**再帰的データ型**で最も自然に表現されます：
-
-1. **再帰的 ADT**: 個別要素と複合要素を同じ型で定義
-2. **パターンマッチ + 再帰**: 統一的な操作を簡潔に記述
-3. **不変性**: 構造の変更は新しいツリーを生成
-
-## 言語別個別記事
-
-- [Clojure](../clojure/07-composite-pattern.md) | [Scala](../scala/07-composite-pattern.md) | [Elixir](../elixir/07-effects-and-pure-functions.md) | [F#](../fsharp/07-composite-pattern.md) | [Haskell](../haskell/07-composite-pattern.md) | [Rust](../rust/07-composite-pattern.md)

package/lib/assets/docs/article/functional-desgin-ppp/all/08-decorator-pattern.md

@@ -1,300 +0,0 @@
----
-type: Article
-title: "第8章: Decorator パターン — 6言語統合ガイド"
-description: "Decorator パターンは、既存の機能に新しい振る舞いを動的に追加する GoF パターンです。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第8章: Decorator パターン — 6言語統合ガイド
-
-## 1. はじめに
-
-Decorator パターンは、既存の機能に新しい振る舞いを動的に追加する GoF パターンです。OOP ではラッパークラスを重ねますが、関数型プログラミングでは**高階関数とクロージャ**がデコレータの役割を果たします。関数を受け取り、拡張された関数を返す — これが関数型デコレータの本質です。
-
-> **Elixir の読者へ**: Elixir 版は本章で「エラーハンドリング戦略」を扱っています。Elixir 固有のアプローチについては[コラム](#elixir-コラムエラーハンドリング戦略)を参照してください。
-
-## 2. 共通の本質
-
-### Decorator の構造
-
-```
-decorator(f) → g
-  where g(x) = 前処理 + f(x) + 後処理
-```
-
-- **横断的関心事の分離**: ロギング、キャッシュ、リトライなどをビジネスロジックから分離
-- **合成可能性**: 複数のデコレータを連鎖的に適用
-- **透過性**: デコレートされた関数は元の関数と同じインターフェース
-
-### 典型的なデコレータ
-
-- **ロギング**: 入出力を記録
-- **キャッシュ**: 結果をメモ化
-- **リトライ**: 失敗時に再試行
-- **タイミング**: 実行時間を計測
-- **バリデーション**: 入力を事前検証
-
-## 3. 言語別実装比較
-
-### 3.1 デコレータの実現方法
-
-| 言語 | デコレータの表現 | 状態管理 |
-|------|---------------|---------|
-| Clojure | 高階関数 + クロージャ | `atom` で可変状態 |
-| Scala | 高階関数 / trait ラッパー | `var` / `mutable.Map` |
-| F# | 高階関数 + パイプライン | `mutable` / `Dictionary` |
-| Haskell | 高階関数 + IO モナド | `IORef` / 純粋な Map 返却 |
-| Rust | クロージャ + `Rc<RefCell<T>>` | 共有可変参照 |
-
-### 3.2 ロギングデコレータ
-
-<details>
-<summary>全言語のロギングデコレータ比較</summary>
-
-```clojure
-;; Clojure
-(defn with-logging [f name]
-  (fn [& args]
-    (println (str "Calling " name " with " args))
-    (let [result (apply f args)]
-      (println (str name " returned " result))
-      result)))
-
-;; 使用
-(def logged-add (with-logging + "add"))
-(logged-add 1 2 3) ;; => 6（ログ出力付き）
-```
-
-```scala
-// Scala
-def withLogging[A, B](f: A => B, name: String): A => B =
-  input =>
-    println(s"Calling $name with $input")
-    val result = f(input)
-    println(s"$name returned $result")
-    result
-```
-
-```fsharp
-// F#
-let withLogging (name: string) (f: 'a -> 'b) : 'a -> 'b =
-    fun input ->
-        printfn "Calling %s with %A" name input
-        let result = f input
-        printfn "%s returned %A" name result
-        result
-```
-
-```haskell
--- Haskell
-withLogging :: Show a => Show b => String -> (a -> b) -> a -> IO b
-withLogging name f input = do
-    putStrLn $ "Calling " ++ name ++ " with " ++ show input
-    let result = f input
-    putStrLn $ name ++ " returned " ++ show result
-    return result
-```
-
-Haskell ではロギングが副作用であるため、戻り値の型が `IO b` に変わる点に注目してください。
-
-```rust
-// Rust
-pub fn with_logging<F, A, B>(f: F, name: &str) -> impl Fn(A) -> B + '_
-where
-    F: Fn(A) -> B,
-    A: std::fmt::Debug,
-    B: std::fmt::Debug,
-{
-    move |input| {
-        println!("Calling {} with {:?}", name, input);
-        let result = f(input);
-        println!("{} returned {:?}", name, result);
-        result
-    }
-}
-```
-
-</details>
-
-### 3.3 キャッシュデコレータ
-
-キャッシュデコレータは状態（キャッシュストア）を持つため、言語ごとの状態管理の違いが顕著に現れます。
-
-<details>
-<summary>キャッシュデコレータの状態管理比較</summary>
-
-```clojure
-;; Clojure: atom でスレッドセーフな可変状態
-(defn with-cache [f]
-  (let [cache (atom {})]
-    (fn [& args]
-      (if-let [cached (get @cache args)]
-        cached
-        (let [result (apply f args)]
-          (swap! cache assoc args result)
-          result)))))
-```
-
-```scala
-// Scala: mutable.Map
-def withCache[A, B](f: A => B): A => B =
-  val cache = scala.collection.mutable.Map.empty[A, B]
-  input => cache.getOrElseUpdate(input, f(input))
-```
-
-```haskell
--- Haskell: 純粋版（Map を状態として返す）
-withCache :: Ord a => (a -> b) -> a -> Map a b -> (b, Map a b)
-withCache f input cache = case Map.lookup input cache of
-    Just result -> (result, cache)
-    Nothing     -> let result = f input
-                   in (result, Map.insert input result cache)
-```
-
-Haskell の純粋版はキャッシュの状態を**戻り値として返す**ため、副作用がありません。
-
-```rust
-// Rust: Rc<RefCell<HashMap>>
-pub fn with_cache<F, A, B>(f: F) -> impl Fn(A) -> B
-where
-    F: Fn(&A) -> B,
-    A: Eq + Hash + Clone,
-    B: Clone,
-{
-    let cache = Rc::new(RefCell::new(HashMap::new()));
-    move |input| {
-        if let Some(result) = cache.borrow().get(&input) {
-            return result.clone();
-        }
-        let result = f(&input);
-        cache.borrow_mut().insert(input, result.clone());
-        result
-    }
-}
-```
-
-</details>
-
-### 3.4 デコレータの合成
-
-複数のデコレータを連鎖的に適用するパターンです。
-
-<details>
-<summary>デコレータ合成の比較</summary>
-
-```clojure
-;; Clojure: comp で合成
-(defn compose-decorators [f & decorators]
-  (reduce (fn [acc dec] (dec acc)) f decorators))
-
-(def enhanced-fn
-  (compose-decorators my-fn
-    (partial with-logging "my-fn")
-    with-cache
-    (partial with-retry 3)))
-```
-
-```scala
-// Scala: andThen チェーン
-val enhancedFn =
-  withLogging("calc", _: Int => Int) andThen
-  withCache andThen
-  withRetry(3)
-```
-
-```fsharp
-// F# : パイプライン
-let enhancedFn =
-    myFn
-    |> withLogging "myFn"
-    |> withCache
-    |> withRetry 3
-```
-
-</details>
-
-### 3.5 JournaledShape（操作履歴デコレータ）
-
-すべての言語で共通して実装される「操作履歴を記録するデコレータ」です。
-
-| 言語 | 実装 | 履歴の保持方法 |
-|------|------|-------------|
-| Clojure | マップ + `:journal` キー | 不変リスト |
-| Scala | `JournaledShape` case class | `Vector[String]` |
-| F# | `JournaledShape` レコード | `string list` |
-| Haskell | `JournaledShape` データ型 | `[String]` |
-| Rust | `JournaledShape<S>` ジェネリクス | `Vec<String>` |
-
-## 4. 比較分析
-
-### 4.1 副作用の扱い
-
-デコレータは本質的に副作用（ロギング、キャッシュ）を扱うため、言語の副作用管理戦略が直接影響します。
-
-| 言語 | 副作用の扱い | デコレータへの影響 |
-|------|-----------|----------------|
-| Clojure | 規約ベース | `atom` で自由に状態管理 |
-| Scala | 自由（ただし推奨は純粋） | `var` / `mutable` を局所的に使用 |
-| F# | 基本は純粋、`mutable` で例外 | 明示的な可変性宣言 |
-| Haskell | IO モナドで厳密に分離 | 副作用デコレータは `IO` 型に |
-| Rust | 所有権で管理 | `Rc<RefCell<T>>` で共有可変状態 |
-
-### 4.2 型の変化
-
-Haskell ではデコレータの追加により**型が変化**します（`a -> b` が `a -> IO b` に）。他の言語ではデコレートしても型が変わりません。これは Haskell の純粋性保証の強さの表れです。
-
-## 5. Elixir コラム：エラーハンドリング戦略
-
-Elixir の第 8 章は Decorator パターンではなく、**エラーハンドリング戦略**を扱っています。
-
-### Railway Oriented Programming
-
-```elixir
-# {:ok, value} / {:error, reason} による逐次処理
-def process(params) do
-  with {:ok, validated} <- validate(params),
-       {:ok, saved} <- save(validated),
-       {:ok, notified} <- notify(saved) do
-    {:ok, notified}
-  end
-end
-```
-
-### リトライとフォールバック
-
-```elixir
-def retry(f, max_attempts, attempt \\ 1) do
-  case f.() do
-    {:ok, result} -> {:ok, result}
-    {:error, _} when attempt < max_attempts ->
-      Process.sleep(100 * attempt)
-      retry(f, max_attempts, attempt + 1)
-    {:error, reason} -> {:error, reason}
-  end
-end
-
-def fallback_chain(strategies) do
-  Enum.reduce_while(strategies, {:error, :no_strategy}, fn strategy, _acc ->
-    case strategy.() do
-      {:ok, result} -> {:halt, {:ok, result}}
-      {:error, _} -> {:cont, {:error, :all_failed}}
-    end
-  end)
-end
-```
-
-Decorator パターンの「機能の動的追加」は、Elixir ではパイプラインと `with` 式による関数チェーンとして表現されます。
-
-## 6. まとめ
-
-Decorator パターンは、関数型プログラミングで**高階関数**として最も自然に表現されます：
-
-1. **関数がデコレータ**: 関数を受け取り、拡張された関数を返す
-2. **横断的関心事の分離**: ロギング・キャッシュ・リトライを独立した高階関数に
-3. **合成可能性**: `comp` / `andThen` / `|>` で複数デコレータを連鎖
-
-## 言語別個別記事
-
-- [Clojure](../clojure/08-decorator-pattern.md) | [Scala](../scala/08-decorator-pattern.md) | [Elixir](../elixir/08-error-handling-strategies.md) | [F#](../fsharp/08-decorator-pattern.md) | [Haskell](../haskell/08-decorator-pattern.md) | [Rust](../rust/08-decorator-pattern.md)