@k2works/claude-code-booster 6.2.0 → 6.3.1

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

@@ -1,295 +0,0 @@
----
-type: Article
-title: "第11章: Command パターン — 6言語統合ガイド"
-description: "Command パターンは、「リクエストをオブジェクトとしてカプセル化する」GoF パターンです。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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

@@ -1,331 +0,0 @@
----
-type: Article
-title: "第12章: Visitor パターン — 6言語統合ガイド"
-description: "Visitor パターンは、データ構造と操作を分離する GoF パターンです。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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)