@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/all/13-abstract-factory-pattern.md

@@ -0,0 +1,319 @@
+# 第13章: Abstract Factory パターン — 6言語統合ガイド
+
+## 1. はじめに
+
+Abstract Factory パターンは、関連するオブジェクトのファミリーを一貫した方法で生成する GoF パターンです。OOP ではファクトリインターフェースと具象ファクトリクラスを用いますが、関数型プログラミングでは**ファクトリ関数のレコード / マップ / モジュール**として表現されます。スタイル付き図形、プラットフォーム別 UI、データベースアダプターなどの生成を統一的に管理します。
+
+## 2. 共通の本質
+
+### Abstract Factory の構造
+
+```
+Factory = { createA: params → A, createB: params → B }
+```
+
+- **製品ファミリー**: 一貫したスタイル/テーマの製品群を生成
+- **ファクトリの差し替え**: 実行時にファクトリを切り替えて製品群を変更
+- **一貫性の保証**: 同じファクトリから生成された製品は互いに整合
+
+### 典型的なユースケース
+
+- **図形ファクトリ**: Standard / Outlined / Filled スタイルの図形生成
+- **UI ファクトリ**: Windows / Mac / Linux 向けのコンポーネント生成
+- **データベースファクトリ**: MySQL / PostgreSQL / SQLite の接続生成
+
+## 3. 言語別実装比較
+
+### 3.1 ファクトリの表現方法
+
+| 言語 | ファクトリ表現 | 製品の表現 |
+|------|-------------|----------|
+| Clojure | 関数のマップ / マルチメソッド | マップ |
+| Scala | trait + object | case class |
+| Elixir | プロトコル + 構造体 | 構造体 |
+| F# | 判別共用体 / 関数レコード | レコード |
+| Haskell | 型クラス / 関数レコード | ADT |
+| Rust | trait + struct | struct |
+
+### 3.2 図形ファクトリ
+
+<details>
+<summary>Scala: trait + object</summary>
+
+```scala
+trait ShapeFactory:
+  def createCircle(center: Point, radius: Double): Shape
+  def createSquare(topLeft: Point, side: Double): Shape
+  def createRectangle(topLeft: Point, width: Double, height: Double): Shape
+
+object StandardShapeFactory extends ShapeFactory:
+  def createCircle(center: Point, radius: Double): Shape =
+    Circle(center, radius)
+  def createSquare(topLeft: Point, side: Double): Shape =
+    Square(topLeft, side)
+  def createRectangle(topLeft: Point, w: Double, h: Double): Shape =
+    Rectangle(topLeft, w, h)
+
+object OutlinedShapeFactory extends ShapeFactory:
+  def createCircle(center: Point, radius: Double): Shape =
+    StyledShape(Circle(center, radius), Style(outline = true, color = "black"))
+  // ...
+```
+
+</details>
+
+<details>
+<summary>Haskell: 型クラス</summary>
+
+```haskell
+class ShapeFactory f where
+    createCircle    :: f -> Point -> Double -> Shape
+    createSquare    :: f -> Point -> Double -> Shape
+    createRectangle :: f -> Point -> Double -> Double -> Shape
+
+data StandardFactory = StandardFactory
+data OutlinedFactory = OutlinedFactory String Float
+
+instance ShapeFactory StandardFactory where
+    createCircle _ center radius = Circle center radius
+    createSquare _ topLeft side  = Square topLeft side
+    createRectangle _ tl w h     = Rectangle tl w h
+
+instance ShapeFactory OutlinedFactory where
+    createCircle (OutlinedFactory color width) center radius =
+        StyledShape (Circle center radius) (Style color width)
+    -- ...
+```
+
+</details>
+
+<details>
+<summary>F#: 判別共用体によるファクトリ選択</summary>
+
+```fsharp
+type ShapeFactory =
+    | Standard
+    | Outlined of color: string * width: float
+    | Filled of color: string
+
+module ShapeFactory =
+    let createCircle (factory: ShapeFactory) (center: Point) (radius: float) =
+        let baseShape = Circle(center, radius)
+        match factory with
+        | Standard -> baseShape
+        | Outlined(color, width) ->
+            StyledShape(baseShape, { OutlineColor = color; OutlineWidth = width })
+        | Filled(color) ->
+            StyledShape(baseShape, { FillColor = color })
+
+    let createSquare (factory: ShapeFactory) (topLeft: Point) (side: float) =
+        let baseShape = Square(topLeft, side)
+        match factory with
+        | Standard -> baseShape
+        | Outlined(color, width) ->
+            StyledShape(baseShape, { OutlineColor = color; OutlineWidth = width })
+        | Filled(color) ->
+            StyledShape(baseShape, { FillColor = color })
+```
+
+</details>
+
+<details>
+<summary>Rust: trait + struct</summary>
+
+```rust
+pub trait ShapeFactory {
+    fn create_circle(&self, center: Point, radius: f64) -> Shape;
+    fn create_square(&self, top_left: Point, side: f64) -> Shape;
+}
+
+pub struct StandardFactory;
+
+impl ShapeFactory for StandardFactory {
+    fn create_circle(&self, center: Point, radius: f64) -> Shape {
+        Shape::Circle { center, radius }
+    }
+    fn create_square(&self, top_left: Point, side: f64) -> Shape {
+        Shape::Square { top_left, side }
+    }
+}
+
+pub struct OutlinedFactory {
+    pub color: String,
+    pub width: f64,
+}
+
+impl ShapeFactory for OutlinedFactory {
+    fn create_circle(&self, center: Point, radius: f64) -> Shape {
+        Shape::Styled {
+            shape: Box::new(Shape::Circle { center, radius }),
+            style: Style { outline_color: self.color.clone(), outline_width: self.width },
+        }
+    }
+    // ...
+}
+```
+
+</details>
+
+<details>
+<summary>Clojure: 関数のマップ</summary>
+
+```clojure
+(def standard-factory
+  {:create-circle (fn [center radius]
+                    {:type :circle :center center :radius radius})
+   :create-square (fn [top-left side]
+                    {:type :square :top-left top-left :side side})})
+
+(def outlined-factory
+  {:create-circle (fn [center radius]
+                    {:type :styled-shape
+                     :shape {:type :circle :center center :radius radius}
+                     :style {:outline true :color "black"}})
+   :create-square (fn [top-left side]
+                    {:type :styled-shape
+                     :shape {:type :square :top-left top-left :side side}
+                     :style {:outline true :color "black"}})})
+
+;; ファクトリの利用
+(defn draw-scene [factory]
+  (let [circle ((:create-circle factory) {:x 0 :y 0} 5)
+        square ((:create-square factory) {:x 10 :y 10} 3)]
+    [circle square]))
+```
+
+</details>
+
+<details>
+<summary>Elixir: プロトコル + 構造体</summary>
+
+```elixir
+defprotocol ShapeFactory do
+  def create_circle(factory, center, radius)
+  def create_square(factory, top_left, side)
+end
+
+defmodule StandardShapeFactory do
+  defstruct []
+end
+
+defimpl ShapeFactory, for: StandardShapeFactory do
+  def create_circle(_factory, center, radius) do
+    %Circle{center: center, radius: radius}
+  end
+
+  def create_square(_factory, top_left, side) do
+    %Square{top_left: top_left, side: side}
+  end
+end
+
+defmodule OutlinedShapeFactory do
+  defstruct [:outline_color, :outline_width]
+end
+
+defimpl ShapeFactory, for: OutlinedShapeFactory do
+  def create_circle(factory, center, radius) do
+    %StyledShape{
+      shape: %Circle{center: center, radius: radius},
+      style: %{color: factory.outline_color, width: factory.outline_width}
+    }
+  end
+  # ...
+end
+```
+
+</details>
+
+### 3.3 UI ファクトリ（プラットフォーム別）
+
+<details>
+<summary>プラットフォーム別 UI 生成の比較</summary>
+
+```rust
+// Rust
+pub trait GUIFactory {
+    fn create_button(&self, label: &str) -> Box<dyn Button>;
+    fn create_checkbox(&self, label: &str, checked: bool) -> Box<dyn Checkbox>;
+}
+
+pub struct WindowsFactory;
+pub struct MacFactory;
+
+impl GUIFactory for WindowsFactory {
+    fn create_button(&self, label: &str) -> Box<dyn Button> {
+        Box::new(WindowsButton { label: label.to_string() })
+    }
+    // ...
+}
+```
+
+```scala
+// Scala
+trait GUIFactory:
+  def createButton(label: String): Button
+  def createCheckbox(label: String, checked: Boolean): Checkbox
+
+object WindowsFactory extends GUIFactory:
+  def createButton(label: String) = WindowsButton(label)
+  def createCheckbox(label: String, checked: Boolean) = WindowsCheckbox(label, checked)
+
+object MacFactory extends GUIFactory:
+  def createButton(label: String) = MacButton(label)
+  def createCheckbox(label: String, checked: Boolean) = MacCheckbox(label, checked)
+```
+
+</details>
+
+## 4. 比較分析
+
+### 4.1 ファクトリの抽象化レベル
+
+| 言語 | 抽象化方法 | 切り替えの容易さ |
+|------|----------|---------------|
+| Clojure | マップの差し替え | 最も柔軟（動的） |
+| Scala | trait の実装切り替え | 型安全に切り替え |
+| Elixir | プロトコル実装の差し替え | プロトコルベースで柔軟 |
+| F# | 判別共用体のパターンマッチ | コンパイル時に網羅性保証 |
+| Haskell | 型クラスインスタンスの選択 | 型推論で自動選択 |
+| Rust | trait object の差し替え | `Box<dyn Factory>` で動的 |
+
+### 4.2 OOP Abstract Factory vs 関数型
+
+| 観点 | OOP | 関数型 |
+|------|-----|--------|
+| ファクトリ | インターフェース + 実装クラス | 関数のレコード / 型クラス / trait |
+| 製品 | 具象クラス | ADT / enum / マップ |
+| 拡張 | 新クラス追加 | 新しいインスタンス / 判別共用体追加 |
+| 依存性注入 | コンストラクタ | 関数引数 |
+
+### 4.3 Elixir 版のボリューム
+
+Elixir 版は 604 行と最も長い記事です。これは以下の理由によります：
+
+- 3-4 種類のファクトリ（Standard, Outlined, Filled, Complex）の完全実装
+- UI ファクトリ（Windows, Mac, Linux）の詳細例
+- データベースファクトリの追加例
+- 各ファクトリのテストコードと使用例
+
+## 5. 実践的な選択指針
+
+| 要件 | 推奨言語 | 理由 |
+|------|---------|------|
+| 動的なファクトリ切り替え | Clojure | マップベースで最も柔軟 |
+| 型安全なファクトリ | Haskell | 型クラスで自動推論 |
+| プラットフォーム別 UI | Rust, Scala | trait ベースの具象ファクトリ |
+| コンパイル時の網羅性保証 | F# | 判別共用体でファクトリ種別を管理 |
+| プロトコルベースの拡張 | Elixir | 既存型に後からファクトリ実装を追加 |
+
+## 6. まとめ
+
+Abstract Factory パターンは、関数型プログラミングで以下のように表現されます：
+
+1. **ファクトリ = 関数の集合**: 生成関数をレコード / マップ / 型クラスでまとめる
+2. **製品ファミリーの一貫性**: 同じファクトリから生成された製品は整合する
+3. **差し替え可能性**: ファクトリを引数として渡すことで実行時に切り替え
+
+## 言語別個別記事
+
+- [Clojure](../clojure/13-abstract-factory-pattern.md) | [Scala](../scala/13-abstract-factory-pattern.md) | [Elixir](../elixir/13-abstract-factory-pattern.md) | [F#](../fsharp/13-abstract-factory-pattern.md) | [Haskell](../haskell/13-abstract-factory-pattern.md) | [Rust](../rust/13-abstract-factory-pattern.md)

package/lib/assets/docs/article/functional-desgin-ppp/all/14-abstract-server-pattern.md

@@ -0,0 +1,365 @@
+# 第14章: Abstract Server パターン — 6言語統合ガイド
+
+## 1. はじめに
+
+Abstract Server パターンは、SOLID 原則の**依存性逆転の原則（DIP）**を実現するパターンです。高レベルモジュールが低レベルモジュールに直接依存するのではなく、**抽象（インターフェース）**に依存することで、実装の差し替えを可能にします。関数型プログラミングでは、型クラス・trait・プロトコル・高階関数がこの抽象化を提供します。
+
+## 2. 共通の本質
+
+### DIP の構造
+
+```
+高レベルモジュール（Client）
+    ↓ 依存
+  抽象（Interface）
+    ↑ 実装
+低レベルモジュール（Server）
+```
+
+- **Client**: 抽象に依存し、具体的な実装を知らない
+- **Interface**: 操作の契約を定義
+- **Server**: 抽象を実装する具体的なモジュール
+
+### 典型的なユースケース
+
+- **Switchable デバイス**: Switch（Client）→ Switchable（Interface）→ Light/Fan/Motor（Server）
+- **リポジトリ**: Service → Repository → InMemory / Database
+- **ロガー**: Application → Logger → Console / File / Test
+
+## 3. 言語別実装比較
+
+### 3.1 抽象インターフェースの表現
+
+| 言語 | 抽象の表現 | DIP の実現 |
+|------|----------|----------|
+| Clojure | プロトコル（`defprotocol`） | プロトコル実装の差し替え |
+| Scala | trait / given | 型クラスインスタンスの選択 |
+| Elixir | プロトコル / `@behaviour` | `defimpl` / `@behaviour` 実装 |
+| F# | インターフェース | インターフェース実装の差し替え |
+| Haskell | 型クラス（`class`） | インスタンスの選択 |
+| Rust | trait | trait 実装の差し替え |
+
+### 3.2 Switchable パターン
+
+すべての言語で共通する典型例：Switch（Client）が Switchable（Interface）に依存し、Light / Fan / Motor（Server）が Switchable を実装します。
+
+<details>
+<summary>Clojure: プロトコル + レコード</summary>
+
+```clojure
+(defprotocol Switchable
+  (turn-on [this])
+  (turn-off [this])
+  (is-on? [this]))
+
+(defrecord Light [state]
+  Switchable
+  (turn-on [this] (assoc this :state :on))
+  (turn-off [this] (assoc this :state :off))
+  (is-on? [this] (= (:state this) :on)))
+
+(defrecord Fan [state speed]
+  Switchable
+  (turn-on [this] (assoc this :state :on :speed :low))
+  (turn-off [this] (assoc this :state :off :speed nil))
+  (is-on? [this] (= (:state this) :on)))
+
+;; Client: Switch は Switchable にのみ依存
+(defn toggle [device]
+  (if (is-on? device) (turn-off device) (turn-on device)))
+```
+
+</details>
+
+<details>
+<summary>Scala: given + 型クラス</summary>
+
+```scala
+trait Switchable[A]:
+  def turnOn(device: A): A
+  def turnOff(device: A): A
+  def isOn(device: A): Boolean
+
+case class Light(state: LightState = LightState.Off)
+
+given Switchable[Light] with
+  def turnOn(light: Light): Light = light.copy(state = LightState.On)
+  def turnOff(light: Light): Light = light.copy(state = LightState.Off)
+  def isOn(light: Light): Boolean = light.state == LightState.On
+
+// Client: 型クラス制約で抽象に依存
+def toggle[A: Switchable](device: A): A =
+  val sw = summon[Switchable[A]]
+  if sw.isOn(device) then sw.turnOff(device) else sw.turnOn(device)
+```
+
+</details>
+
+<details>
+<summary>Haskell: 型クラス</summary>
+
+```haskell
+class Switchable a where
+    turnOn  :: a -> a
+    turnOff :: a -> a
+    isOn    :: a -> Bool
+
+data Light = Light { lightState :: SwitchState, lightName :: String }
+    deriving (Show, Eq)
+
+instance Switchable Light where
+    turnOn light  = light { lightState = On }
+    turnOff light = light { lightState = Off }
+    isOn light    = lightState light == On
+
+data Fan = Fan { fanState :: SwitchState, fanSpeed :: Maybe Speed }
+    deriving (Show, Eq)
+
+instance Switchable Fan where
+    turnOn fan  = fan { fanState = On, fanSpeed = Just Low }
+    turnOff fan = fan { fanState = Off, fanSpeed = Nothing }
+    isOn fan    = fanState fan == On
+
+-- Client: 型クラス制約で抽象に依存
+toggle :: Switchable a => a -> a
+toggle device = if isOn device then turnOff device else turnOn device
+```
+
+</details>
+
+<details>
+<summary>Rust: trait</summary>
+
+```rust
+pub trait Switchable {
+    fn turn_on(&self) -> Self;
+    fn turn_off(&self) -> Self;
+    fn is_on(&self) -> bool;
+}
+
+pub struct Light { pub state: bool }
+
+impl Switchable for Light {
+    fn turn_on(&self) -> Self { Light { state: true } }
+    fn turn_off(&self) -> Self { Light { state: false } }
+    fn is_on(&self) -> bool { self.state }
+}
+
+pub struct Fan { pub state: bool, pub speed: Option<Speed> }
+
+impl Switchable for Fan {
+    fn turn_on(&self) -> Self {
+        Fan { state: true, speed: Some(Speed::Low) }
+    }
+    fn turn_off(&self) -> Self {
+        Fan { state: false, speed: None }
+    }
+    fn is_on(&self) -> bool { self.state }
+}
+
+// Client: ジェネリクス + trait 境界
+pub fn toggle<T: Switchable>(device: &T) -> T {
+    if device.is_on() { device.turn_off() } else { device.turn_on() }
+}
+```
+
+</details>
+
+<details>
+<summary>F#: インターフェース</summary>
+
+```fsharp
+type ISwitchable =
+    abstract member TurnOn: unit -> ISwitchable
+    abstract member TurnOff: unit -> ISwitchable
+    abstract member IsOn: bool
+
+type Light = { State: bool }
+    with
+    interface ISwitchable with
+        member this.TurnOn() = { State = true } :> ISwitchable
+        member this.TurnOff() = { State = false } :> ISwitchable
+        member this.IsOn = this.State
+
+// Client
+let toggle (device: ISwitchable) =
+    if device.IsOn then device.TurnOff() else device.TurnOn()
+```
+
+</details>
+
+<details>
+<summary>Elixir: プロトコル</summary>
+
+```elixir
+defprotocol Switchable do
+  def turn_on(device)
+  def turn_off(device)
+  def on?(device)
+end
+
+defmodule Light do
+  defstruct state: :off, brightness: 100
+end
+
+defimpl Switchable, for: Light do
+  def turn_on(light), do: %{light | state: :on}
+  def turn_off(light), do: %{light | state: :off}
+  def on?(%Light{state: state}), do: state == :on
+end
+
+# Client
+defmodule Switch do
+  def toggle(device) do
+    if Switchable.on?(device),
+      do: Switchable.turn_off(device),
+      else: Switchable.turn_on(device)
+  end
+end
+```
+
+</details>
+
+### 3.3 リポジトリパターン（DIP の実践）
+
+データ永続化の抽象化は DIP の代表的な活用例です。
+
+<details>
+<summary>リポジトリの抽象化比較</summary>
+
+```haskell
+-- Haskell: 型クラス
+class Repository m where
+    save   :: Entity -> m ()
+    findById :: String -> m (Maybe Entity)
+    findAll  :: m [Entity]
+
+-- インメモリ実装
+instance Repository (State (Map String Entity)) where
+    save entity = modify (Map.insert (entityId entity) entity)
+    findById id = gets (Map.lookup id)
+    findAll = gets Map.elems
+```
+
+```rust
+// Rust: trait
+pub trait Repository<T> {
+    fn save(&mut self, entity: T) -> Result<(), String>;
+    fn find_by_id(&self, id: &str) -> Option<&T>;
+    fn find_all(&self) -> Vec<&T>;
+}
+
+pub struct InMemoryRepository<T> {
+    store: HashMap<String, T>,
+}
+
+impl<T: HasId> Repository<T> for InMemoryRepository<T> {
+    fn save(&mut self, entity: T) -> Result<(), String> {
+        self.store.insert(entity.id().to_string(), entity);
+        Ok(())
+    }
+    fn find_by_id(&self, id: &str) -> Option<&T> {
+        self.store.get(id)
+    }
+    fn find_all(&self) -> Vec<&T> {
+        self.store.values().collect()
+    }
+}
+```
+
+```scala
+// Scala: trait
+trait Repository[T]:
+  def save(entity: T): Unit
+  def findById(id: String): Option[T]
+  def findAll: List[T]
+
+class InMemoryRepository[T] extends Repository[T]:
+  private val store = scala.collection.mutable.Map.empty[String, T]
+  def save(entity: T): Unit = store += (entity.id -> entity)
+  def findById(id: String): Option[T] = store.get(id)
+  def findAll: List[T] = store.values.toList
+```
+
+</details>
+
+### 3.4 ロガーパターン
+
+テスト可能なロギングの抽象化です。
+
+| 言語 | 本番用 | テスト用 |
+|------|--------|---------|
+| Clojure | `println` を呼ぶ実装 | `atom` に蓄積する実装 |
+| Scala | `ConsoleLogger` | `TestLogger`（`var` で蓄積） |
+| Elixir | `ConsoleLogger` | `TestLogger`（Agent で蓄積） |
+| F# | `ConsoleLogger` | `TestLogger`（`ResizeArray` で蓄積） |
+| Haskell | `IO` ベース | `Writer` モナドベース |
+| Rust | `ConsoleLogger` | `TestLogger`（`Vec` で蓄積） |
+
+## 4. 比較分析
+
+### 4.1 DIP の実現レベル
+
+| 言語 | DIP の強制力 | コンパイル時チェック |
+|------|-----------|-----------------|
+| Clojure | 規約ベース | なし |
+| Scala | 型クラス / given で強制 | 完全 |
+| Elixir | プロトコルで強制 | なし（動的） |
+| F# | インターフェースで強制 | 完全 |
+| Haskell | 型クラスで強制 | 最も厳密 |
+| Rust | trait 境界で強制 | 完全 |
+
+### 4.2 高階関数による簡易 DIP
+
+型クラスや trait を使わなくても、**高階関数**で簡易的に DIP を実現できます：
+
+```clojure
+;; Clojure: 関数を渡すだけ
+(defn process [data save-fn log-fn]
+  (log-fn "Processing...")
+  (save-fn (transform data))
+  (log-fn "Done"))
+```
+
+```haskell
+-- Haskell: 関数を渡す
+process :: (String -> IO ()) -> (a -> IO ()) -> a -> IO ()
+process logger saver data = do
+    logger "Processing..."
+    saver (transform data)
+    logger "Done"
+```
+
+この方法は小規模なケースでは十分ですが、操作が多数ある場合は型クラス / trait / プロトコルの方が整理しやすくなります。
+
+### 4.3 Elixir 版のボリューム
+
+Elixir 版は 729 行と全言語中最長です。これは以下を詳細に扱っているためです：
+
+- Light / Fan / Motor の 3 種類のデバイス実装
+- Repository パターン（User, Product）の完全実装
+- Logger インターフェースの複数実装
+- 複合サービスの統合例
+- 各パターンのテストコード
+
+## 5. 実践的な選択指針
+
+| 要件 | 推奨言語 | 理由 |
+|------|---------|------|
+| 最も厳密な DIP | Haskell | 型クラスによるコンパイル時強制 |
+| 実用的な DIP | Rust, Scala | trait / given で型安全に抽象化 |
+| 動的な実装切り替え | Clojure | プロトコル + 高階関数で柔軟 |
+| アクターモデルとの統合 | Elixir | プロトコル + GenServer で状態管理 |
+| .NET エコシステム統合 | F# | インターフェースで C# と相互運用 |
+
+## 6. まとめ
+
+Abstract Server パターンは、SOLID の DIP を関数型で実現する基盤です：
+
+1. **型クラス / trait / プロトコル**: 抽象インターフェースを言語の仕組みで表現
+2. **実装の差し替え**: テスト用モック、本番用実装を同じインターフェースで切り替え
+3. **高階関数による簡易 DIP**: 小規模なケースでは関数を渡すだけでも十分
+
+## 言語別個別記事
+
+- [Clojure](../clojure/14-abstract-server-pattern.md) | [Scala](../scala/14-abstract-server-pattern.md) | [Elixir](../elixir/14-abstract-server-pattern.md) | [F#](../fsharp/14-abstract-server-pattern.md) | [Haskell](../haskell/14-abstract-server-pattern.md) | [Rust](../rust/14-abstract-server-pattern.md)