@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/all/11-command-pattern.md

@@ -0,0 +1,286 @@
+# 第11章: Command パターン — 6言語統合ガイド
+
+## 1. はじめに
+
+Command パターンは、「リクエストをオブジェクトとしてカプセル化する」GoF パターンです。OOP ではコマンドインターフェースと実装クラスを用いますが、関数型プログラミングでは**関数そのものがコマンド**になります。不変データ構造と組み合わせることで、Undo/Redo やバッチ実行が自然に実現できます。
+
+## 2. 共通の本質
+
+### コマンドの構造
+
+```
+Command = { execute: State → State, undo: State → State }
+```
+
+すべての言語で共通する設計：
+
+- **コマンドは状態変換関数**: 現在の状態を受け取り、新しい状態を返す
+- **Undo は逆変換**: execute の逆操作を同じインターフェースで表現
+- **MacroCommand**: 複数のコマンドを集約し、順次実行する合成パターン
+
+### 典型的なユースケース
+
+- **テキストエディタ**: Insert / Delete / Replace コマンド + Undo/Redo
+- **計算機**: 四則演算コマンドの履歴管理
+- **バッチ処理**: コマンドキューの順次実行
+
+## 3. 言語別実装比較
+
+### 3.1 コマンドの型表現
+
+| 言語 | コマンド表現 | ディスパッチ方法 |
+|------|-----------|----------------|
+| Clojure | マップ + マルチメソッド | `:type` キーでディスパッチ |
+| Scala | `trait Command[S]` + case class | パターンマッチ / メソッド呼び出し |
+| Elixir | プロトコル + 構造体 | `defimpl` でディスパッチ |
+| F# | 判別共用体 `TextCommand` | `match` 式 |
+| Haskell | ADT `TextCommand` | `case` 式 |
+| Rust | `trait Command` + struct | trait メソッド呼び出し |
+
+<details>
+<summary>Clojure: マップ + マルチメソッド</summary>
+
+```clojure
+(defmulti execute :type)
+
+(defmethod execute :insert-command [{:keys [position text]}]
+  (fn [doc]
+    (str (subs doc 0 position) text (subs doc position))))
+
+(defmethod execute :delete-command [{:keys [start end]}]
+  (fn [doc]
+    (str (subs doc 0 start) (subs doc end))))
+
+;; コマンドはマップとして生成
+(def cmd {:type :insert-command :position 0 :text "Hello"})
+(def new-doc ((execute cmd) "World"))
+```
+
+Clojure ではコマンドが**関数を返す**パターンを採用しています。execute はコマンドマップを受け取り、状態変換関数を返します。
+
+</details>
+
+<details>
+<summary>Scala: trait + case class</summary>
+
+```scala
+trait Command[S]:
+  def execute(state: S): S
+  def undo(state: S): S
+
+case class InsertCommand(position: Int, text: String) extends Command[String]:
+  def execute(doc: String): String =
+    doc.substring(0, position) + text + doc.substring(position)
+  def undo(doc: String): String =
+    doc.substring(0, position) + doc.substring(position + text.length)
+
+case class MacroCommand[S](commands: List[Command[S]]) extends Command[S]:
+  def execute(state: S): S = commands.foldLeft(state)(_.execute(_))
+  def undo(state: S): S = commands.reverse.foldLeft(state)(_.undo(_))
+```
+
+型パラメータ `[S]` により、任意の状態型に対してコマンドを定義できます。
+
+</details>
+
+<details>
+<summary>F#: 判別共用体</summary>
+
+```fsharp
+[<RequireQualifiedAccess>]
+type TextCommand =
+    | Insert of position: int * text: string
+    | Delete of startPos: int * endPos: int * deletedText: string
+    | Replace of position: int * oldText: string * newText: string
+
+module TextCommand =
+    let execute (command: TextCommand) (document: string) : string =
+        match command with
+        | TextCommand.Insert(pos, text) ->
+            document.[..pos-1] + text + document.[pos..]
+        | TextCommand.Delete(startPos, endPos, _) ->
+            document.[..startPos-1] + document.[endPos..]
+        | TextCommand.Replace(pos, oldText, newText) ->
+            document.Replace(oldText, newText)
+
+    let undo (command: TextCommand) (document: string) : string =
+        match command with
+        | TextCommand.Insert(pos, text) ->
+            document.[..pos-1] + document.[pos + text.Length..]
+        | TextCommand.Delete(startPos, _, deletedText) ->
+            document.[..startPos-1] + deletedText + document.[startPos..]
+        | TextCommand.Replace(pos, oldText, newText) ->
+            document.Replace(newText, oldText)
+```
+
+</details>
+
+<details>
+<summary>Haskell: ADT + パターンマッチ</summary>
+
+```haskell
+data TextCommand
+    = InsertCommand Int String
+    | DeleteCommand Int Int
+    | ReplaceCommand Int String String
+
+executeTextCommand :: TextCommand -> String -> String
+executeTextCommand cmd text = case cmd of
+    InsertCommand pos str ->
+        let (before, after) = splitAt pos text
+        in before ++ str ++ after
+    DeleteCommand start end ->
+        let (before, rest) = splitAt start text
+        in before ++ drop (end - start) rest
+    ReplaceCommand _ old new ->
+        replace old new text
+```
+
+</details>
+
+<details>
+<summary>Rust: trait + struct</summary>
+
+```rust
+pub trait Command: CloneCommand {
+    fn execute(&self, doc: &Document) -> Document;
+    fn undo(&self, doc: &Document) -> Document;
+}
+
+pub struct InsertCommand {
+    pub position: usize,
+    pub text: String,
+}
+
+impl Command for InsertCommand {
+    fn execute(&self, doc: &Document) -> Document {
+        let content = format!("{}{}{}",
+            &doc.content[..self.position],
+            self.text,
+            &doc.content[self.position..]);
+        Document { content }
+    }
+
+    fn undo(&self, doc: &Document) -> Document {
+        let content = format!("{}{}",
+            &doc.content[..self.position],
+            &doc.content[self.position + self.text.len()..]);
+        Document { content }
+    }
+}
+```
+
+</details>
+
+<details>
+<summary>Elixir: プロトコル + defimpl</summary>
+
+```elixir
+defprotocol Command do
+  def execute(command, state)
+  def undo(command, state)
+end
+
+defmodule InsertCommand do
+  defstruct [:pos, :text]
+end
+
+defimpl Command, for: InsertCommand do
+  def execute(%InsertCommand{pos: p, text: t}, doc) do
+    before = String.slice(doc, 0, p)
+    after = String.slice(doc, p..-1//1)
+    before <> t <> after
+  end
+
+  def undo(%InsertCommand{pos: p, text: t}, doc) do
+    before = String.slice(doc, 0, p)
+    after = String.slice(doc, (p + String.length(t))..-1//1)
+    before <> after
+  end
+end
+```
+
+Elixir 版はプロトコルベースでシンプルかつ簡潔な実装です。
+
+</details>
+
+### 3.2 Undo/Redo の実装
+
+すべての言語で**履歴スタック**を用いた Undo/Redo を実装します。不変データ構造との組み合わせにより、状態の巻き戻しが安全に行えます。
+
+| 言語 | 履歴管理 | 状態の巻き戻し |
+|------|---------|--------------|
+| Clojure | リスト（undo-stack / redo-stack） | 不変マップの差し替え |
+| Scala | `List[Command[S]]` | case class の再構築 |
+| Elixir | リスト | 構造体の再構築 |
+| F# | `Command list` | レコードの再構築 |
+| Haskell | `[TextCommand]` | 純粋関数で新状態生成 |
+| Rust | `Vec<Box<dyn Command>>` | clone + 新インスタンス |
+
+### 3.3 MacroCommand（コマンドの合成）
+
+複数のコマンドを 1 つのコマンドとして扱うパターンです。
+
+```
+MacroCommand.execute = commands.foldLeft(state)(cmd.execute)
+MacroCommand.undo    = commands.reverse.foldLeft(state)(cmd.undo)
+```
+
+| 言語 | 合成方法 |
+|------|---------|
+| Clojure | `reduce` で順次適用 |
+| Scala | `foldLeft` |
+| Elixir | `Enum.reduce` |
+| F# | `List.fold` |
+| Haskell | `foldl'` |
+| Rust | `iter().fold()` |
+
+## 4. 比較分析
+
+### 4.1 関数型 Command vs OOP Command
+
+| 観点 | OOP | 関数型 |
+|------|-----|--------|
+| コマンドの実体 | インターフェース実装クラス | 関数 / ADT / マップ |
+| 状態変更 | ミュータブルな receiver を変更 | 新しい状態を返す |
+| Undo | 逆操作を手動実装 | 逆操作 + 不変状態で安全 |
+| 合成 | Composite パターン | fold / reduce |
+
+### 4.2 不変性による Undo の安全性
+
+関数型の最大の利点は、**状態が不変**であるため Undo が安全なことです。OOP では Undo 時にオブジェクトの状態を元に戻す必要がありますが、関数型では過去の状態をそのまま保持しています。
+
+### 4.3 言語間のボリューム差
+
+| 言語 | 行数 | 特徴 |
+|------|------|------|
+| Clojure | 567 | マルチメソッドの詳細な解説、複数ユースケース |
+| Scala | 408 | 型パラメータの活用、複数の実装例 |
+| F# | 429 | パイプラインとの統合、複合コマンド |
+| Rust | 357 | 所有権管理の詳細解説 |
+| Haskell | 304 | 純粋関数の簡潔な実装 |
+| Elixir | 148 | プロトコルベースの最小実装 |
+
+Elixir 版が最も簡潔なのは、プロトコル + `defimpl` により定型コードが最小化されるためです。
+
+## 5. 実践的な選択指針
+
+| 要件 | 推奨言語 | 理由 |
+|------|---------|------|
+| 動的なコマンド追加 | Clojure | マルチメソッドでオープンに拡張 |
+| 型安全なコマンド合成 | Scala | 型パラメータ付き `Command[S]` |
+| 最小限の実装 | Elixir | プロトコルで簡潔 |
+| コンパイル時の網羅性保証 | F#, Haskell | 判別共用体 / ADT のパターンマッチ |
+| メモリ効率的な履歴管理 | Rust | 所有権による明示的なリソース管理 |
+
+## 6. まとめ
+
+Command パターンの関数型実装は、OOP 版より**自然で安全**です：
+
+1. **関数がコマンド**: 状態変換関数そのものがコマンドの本質
+2. **不変性で安全な Undo**: 過去の状態を破壊しないため、履歴管理が容易
+3. **fold による合成**: MacroCommand は reduce/fold で自然に表現
+
+## 言語別個別記事
+
+- [Clojure](../clojure/11-command-pattern.md) | [Scala](../scala/11-command-pattern.md) | [Elixir](../elixir/11-command-pattern.md) | [F#](../fsharp/11-command-pattern.md) | [Haskell](../haskell/11-command-pattern.md) | [Rust](../rust/11-command-pattern.md)

package/lib/assets/docs/article/functional-desgin-ppp/all/12-visitor-pattern.md

@@ -0,0 +1,322 @@
+# 第12章: Visitor パターン — 6言語統合ガイド
+
+## 1. はじめに
+
+Visitor パターンは、データ構造と操作を分離する GoF パターンです。OOP では「ダブルディスパッチ」を使いますが、関数型プログラミングでは**パターンマッチが Visitor を自然に置き換えます**。データ型の定義と操作関数の分離は、関数型言語の基本設計そのものです。
+
+## 2. 共通の本質
+
+### Visitor の本質
+
+```
+Visitor = データ型の各バリアントに対する操作の集合
+```
+
+OOP では accept/visit メソッドの二重ディスパッチが必要ですが、関数型では**パターンマッチで直接分岐**するだけです。
+
+### 典型的な操作
+
+- **面積計算**: 図形の種類に応じた面積算出
+- **JSON 変換**: 図形をシリアライズ
+- **描画**: 図形の種類に応じた出力
+- **式の評価**: 数式 AST の評価・簡略化
+
+## 3. 言語別実装比較
+
+### 3.1 Visitor の実現方法
+
+| 言語 | Visitor の表現 | パターンマッチ |
+|------|-------------|-------------|
+| Clojure | マルチメソッド | `::type` キーでディスパッチ |
+| Scala | trait + extension / パターンマッチ | `match` 式 |
+| Elixir | プロトコル + `defimpl` | 関数頭部のパターンマッチ |
+| F# | 関数 + `match` 式 | 判別共用体の網羅的マッチ |
+| Haskell | 関数 + `case` 式 | ADT の網羅的マッチ |
+| Rust | 関数 + `match` 式 | enum の網羅的マッチ |
+
+### 3.2 図形の面積計算
+
+<details>
+<summary>Clojure: マルチメソッド</summary>
+
+```clojure
+(defmulti calculate-area ::shape/type)
+
+(defmethod calculate-area ::circle/circle [circle]
+  (* Math/PI (:radius circle) (:radius circle)))
+
+(defmethod calculate-area ::square/square [square]
+  (* (:side square) (:side square)))
+
+(defmethod calculate-area ::rectangle/rectangle [rect]
+  (* (:width rect) (:height rect)))
+```
+
+新しい操作（Visitor）の追加は `defmulti` + `defmethod` を書くだけです。
+
+</details>
+
+<details>
+<summary>Scala: パターンマッチ + 型クラス</summary>
+
+```scala
+// パターンマッチ版
+def area(shape: Shape): Double = shape match
+  case Circle(_, radius)      => math.Pi * radius * radius
+  case Square(_, side)        => side * side
+  case Rectangle(_, w, h)     => w * h
+
+// 型クラス版（拡張メソッド）
+trait HasArea[A]:
+  extension (a: A) def area: Double
+
+given HasArea[Circle] with
+  extension (c: Circle) def area: Double = math.Pi * c.radius * c.radius
+```
+
+Scala は OOP スタイル（accept/visit）と関数型スタイル（パターンマッチ）の両方を提示しています。
+
+</details>
+
+<details>
+<summary>F#: 関数 + パターンマッチ</summary>
+
+```fsharp
+let calculateArea (shape: Shape) : float =
+    match shape with
+    | Shape.Circle(_, r) -> System.Math.PI * r * r
+    | Shape.Square(_, s) -> s * s
+    | Shape.Rectangle(_, w, h) -> w * h
+    | Shape.Composite(_, shapes) ->
+        shapes |> List.sumBy calculateArea
+```
+
+各 Visitor は独立した関数として定義されます。Composite の再帰的な処理もパターンマッチで自然に表現できます。
+
+</details>
+
+<details>
+<summary>Haskell: 関数 + case 式</summary>
+
+```haskell
+shapeArea :: Shape -> Double
+shapeArea shape = case shape of
+    Circle _ r       -> pi * r * r
+    Square _ s       -> s * s
+    Rectangle _ w h  -> w * h
+    Composite _ shs  -> sum (map shapeArea shs)
+```
+
+Haskell では Visitor パターンは**単なる関数**です。型クラスを使えば、新しい型に対して操作を追加することもできます。
+
+</details>
+
+<details>
+<summary>Rust: match 式</summary>
+
+```rust
+pub fn area(shape: &Shape) -> f64 {
+    match shape {
+        Shape::Circle { radius, .. } => std::f64::consts::PI * radius * radius,
+        Shape::Square { side, .. } => side * side,
+        Shape::Rectangle { width, height, .. } => width * height,
+        Shape::Composite { shapes, .. } => shapes.iter().map(area).sum(),
+    }
+}
+```
+
+</details>
+
+<details>
+<summary>Elixir: プロトコル</summary>
+
+```elixir
+defprotocol ShapeVisitor do
+  def visit(visitor, shape)
+end
+
+defmodule AreaVisitor do
+  defstruct []
+end
+
+defimpl ShapeVisitor, for: AreaVisitor do
+  def visit(_visitor, %Circle{radius: r}) do
+    :math.pi() * r * r
+  end
+
+  def visit(_visitor, %Square{side: s}) do
+    s * s
+  end
+end
+```
+
+</details>
+
+### 3.3 JSON シリアライズ（複数 Visitor の例）
+
+面積計算と JSON 変換は、同じデータ型に対する**異なる操作（Visitor）**です。
+
+<details>
+<summary>全言語での JSON Visitor 比較</summary>
+
+```clojure
+;; Clojure
+(defmulti to-json ::shape/type)
+(defmethod to-json ::circle/circle [{:keys [center radius]}]
+  (format "{\"type\":\"circle\",\"radius\":%s}" radius))
+```
+
+```scala
+// Scala
+def toJson(shape: Shape): String = shape match
+  case Circle(Point(x, y), r) =>
+    s"""{"type":"circle","x":$x,"y":$y,"radius":$r}"""
+  case Square(Point(x, y), s) =>
+    s"""{"type":"square","x":$x,"y":$y,"side":$s}"""
+```
+
+```fsharp
+// F#
+let toJson (shape: Shape) : string =
+    match shape with
+    | Shape.Circle((x, y), r) ->
+        sprintf """{"type":"circle","x":%f,"y":%f,"radius":%f}""" x y r
+```
+
+```haskell
+-- Haskell
+shapeToJson :: Shape -> String
+shapeToJson shape = case shape of
+    Circle (Point x y) r ->
+        "{\"type\":\"circle\",\"radius\":" ++ show r ++ "}"
+```
+
+```rust
+// Rust
+pub fn to_json(shape: &Shape) -> String {
+    match shape {
+        Shape::Circle { center, radius } =>
+            format!(r#"{{"type":"circle","radius":{}}}"#, radius),
+        // ...
+    }
+}
+```
+
+</details>
+
+### 3.4 式の評価（AST Visitor）
+
+数式の AST（抽象構文木）に対する操作は、Visitor パターンの高度な活用例です。
+
+<details>
+<summary>数式 AST の評価比較</summary>
+
+```haskell
+-- Haskell
+data Expr
+    = Number Double
+    | Add Expr Expr
+    | Multiply Expr Expr
+    | Variable String
+
+evaluate :: Map String Double -> Expr -> Double
+evaluate vars expr = case expr of
+    Number n       -> n
+    Add l r        -> evaluate vars l + evaluate vars r
+    Multiply l r   -> evaluate vars l * evaluate vars r
+    Variable name  -> vars ! name
+```
+
+```rust
+// Rust
+pub enum Expr {
+    Number(f64),
+    Add(Box<Expr>, Box<Expr>),
+    Multiply(Box<Expr>, Box<Expr>),
+}
+
+pub fn evaluate(expr: &Expr, vars: &HashMap<String, f64>) -> f64 {
+    match expr {
+        Expr::Number(n) => *n,
+        Expr::Add(l, r) => evaluate(l, vars) + evaluate(r, vars),
+        Expr::Multiply(l, r) => evaluate(l, vars) * evaluate(r, vars),
+    }
+}
+```
+
+```fsharp
+// F#
+type Expr =
+    | Number of float
+    | Add of Expr * Expr
+    | Multiply of Expr * Expr
+
+let rec evaluate (vars: Map<string, float>) (expr: Expr) : float =
+    match expr with
+    | Number n -> n
+    | Add(l, r) -> evaluate vars l + evaluate vars r
+    | Multiply(l, r) -> evaluate vars l * evaluate vars r
+```
+
+</details>
+
+## 4. 比較分析
+
+### 4.1 Visitor パターンが不要になる理由
+
+関数型言語では、OOP の Visitor パターンが提供する機能を**パターンマッチが自然に提供**します。
+
+| OOP Visitor の要素 | 関数型の対応 |
+|-------------------|-----------|
+| accept メソッド | 不要（パターンマッチで直接分岐） |
+| visit メソッド群 | 各ケースの処理関数 |
+| ConcreteVisitor | 独立した関数 |
+| ダブルディスパッチ | パターンマッチ |
+| 新しい操作追加 | 新しい関数を定義するだけ |
+
+### 4.2 Expression Problem
+
+Visitor パターンは Expression Problem（新しいデータ型と新しい操作の両方を追加する困難さ）と深く関連しています。
+
+| 追加対象 | 関数型の容易さ | OOP の容易さ |
+|---------|-------------|-------------|
+| 新しい操作 | 容易（関数を追加） | 困難（全クラスに visit 追加） |
+| 新しいデータ型 | 困難（全関数に分岐追加） | 容易（クラスを追加） |
+
+静的型付け言語（F#, Haskell, Rust, Scala）では、データ型を追加した際に**コンパイラが未処理のケースを検出**してくれます。動的型付け言語（Clojure, Elixir）ではテストで確認する必要があります。
+
+### 4.3 fold ベースの汎用 Visitor
+
+Haskell では `fold` を使った汎用的な Visitor パターンを定義できます：
+
+```haskell
+treeFold :: (a -> b) -> (b -> b -> b) -> Tree a -> b
+treeFold leafFn nodeFn tree = case tree of
+    Leaf x       -> leafFn x
+    Node left right -> nodeFn (treeFold leafFn nodeFn left)
+                              (treeFold leafFn nodeFn right)
+```
+
+これにより、任意の操作を fold の引数として渡すだけで新しい Visitor を定義できます。
+
+## 5. 実践的な選択指針
+
+| 要件 | 推奨言語 | 理由 |
+|------|---------|------|
+| 動的な操作追加 | Clojure | マルチメソッドでオープンに拡張 |
+| AST 処理 | Haskell, F# | ADT + パターンマッチが最適 |
+| 既存型への操作追加 | Scala | 型クラス + extension メソッド |
+| コンパイル時の網羅性 | F#, Haskell, Rust | パターンマッチの網羅性チェック |
+| プロトコルベースの拡張 | Elixir | 既存型に後からプロトコル実装を追加可能 |
+
+## 6. まとめ
+
+Visitor パターンは、関数型プログラミングにおいて**最も自然に消滅する**GoF パターンです：
+
+1. **パターンマッチが Visitor**: データ型の分岐は言語の基本機能
+2. **操作の追加が容易**: 新しい関数を定義するだけで新しい Visitor
+3. **Expression Problem**: 新しいデータ型追加時のコンパイラ支援が言語間で異なる
+
+## 言語別個別記事
+
+- [Clojure](../clojure/12-visitor-pattern.md) | [Scala](../scala/12-visitor-pattern.md) | [Elixir](../elixir/12-visitor-pattern.md) | [F#](../fsharp/12-visitor-pattern.md) | [Haskell](../haskell/12-visitor-pattern.md) | [Rust](../rust/12-visitor-pattern.md)