npm - @k2works/claude-code-booster - Versions diffs - 6.1.0 → 6.3.0 - Mend

@k2works/claude-code-booster 6.1.0 → 6.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (622) hide show

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

@@ -1,328 +0,0 @@
----
-type: Article
-title: "第13章: Abstract Factory パターン — 6言語統合ガイド"
-description: "Abstract Factory パターンは、関連するオブジェクトのファミリーを一貫した方法で生成する GoF パターンです。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第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 DELETED Viewed

@@ -1,374 +0,0 @@
----
-type: Article
-title: "第14章: Abstract Server パターン — 6言語統合ガイド"
-description: "Abstract Server パターンは、SOLID 原則の依存性逆転の原則（DIP）を実現するパターンです。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第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)