npm - @k2works/claude-code-booster - Versions diffs - 6.2.0 → 6.3.1 - Mend

@k2works/claude-code-booster 6.2.0 → 6.3.1

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 (618) hide show

package/lib/assets/docs/article/functional-desgin-ppp/all/09-adapter-pattern.md DELETED Viewed

@@ -1,345 +0,0 @@
----
-type: Article
-title: "第9章: Adapter パターン — 6言語統合ガイド"
-description: "Adapter パターンは、互換性のないインターフェースを接続する GoF パターンです。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第9章: Adapter パターン — 6言語統合ガイド
-## 1. はじめに
-Adapter パターンは、互換性のないインターフェースを接続する GoF パターンです。OOP ではラッパークラスを作成しますが、関数型プログラミングでは**変換関数**がアダプターの役割を果たします。データ形式の変換、API の適応、単位変換など、関数型ではデータ変換パイプラインとして自然に表現されます。
-> **Elixir の読者へ**: Elixir 版は本章で「I/O と外部システム」を扱っています。Elixir 固有のアプローチについては[コラム](#elixir-コラムio-と外部システム)を参照してください。
-## 2. 共通の本質
-### Adapter の構造
-```
-adapt: A → B
-  where A = 既存のインターフェース
-        B = 期待されるインターフェース
-```
-- **インターフェース適応**: 既存の型を期待される型に変換
-- **双方向変換**: `A → B` と `B → A` の両方を提供
-- **透過的利用**: アダプターを通じて既存コードを再利用
-### 典型的なユースケース
-- **デバイス制御**: VariableLight（調光） → Switchable（オン/オフ）
-- **データ形式変換**: 旧ユーザー形式 → 新ユーザー形式
-- **API レスポンス変換**: 外部 API のレスポンスを内部モデルに変換
-- **単位変換**: 摂氏 ↔ 華氏、通貨変換
-## 3. 言語別実装比較
-### 3.1 アダプターの実現方法
-| 言語 | アダプター表現 | インターフェース |
-|------|-------------|---------------|
-| Clojure | 変換関数 + マルチメソッド | プロトコル |
-| Scala | trait 実装 / 関数変換 | trait |
-| F# | 関数 + インターフェース | ISwitchable 等 |
-| Haskell | newtype + 型クラスインスタンス | 型クラス |
-| Rust | trait 実装 / 変換関数 | trait |
-### 3.2 デバイスアダプター（VariableLight → Switchable）
-調光可能なライト（VariableLight）を単純なオン/オフスイッチ（Switchable）として使うアダプターです。
-<details>
-<summary>Clojure: プロトコル + 変換関数</summary>
-```clojure
-;; VariableLight は明るさ（0-100）を持つ
-(defn make-variable-light [brightness]
-  {:type :variable-light :brightness brightness})
-;; Switchable プロトコルへの適応
-(defmulti turn-on :type)
-(defmulti turn-off :type)
-(defmulti is-on? :type)
-(defmethod turn-on :variable-light [light]
-  (assoc light :brightness 100))
-(defmethod turn-off :variable-light [light]
-  (assoc light :brightness 0))
-(defmethod is-on? :variable-light [light]
-  (> (:brightness light) 0))
-```
-</details>
-<details>
-<summary>Scala: trait 実装</summary>
-```scala
-trait Switchable:
-  def turnOn: Switchable
-  def turnOff: Switchable
-  def isOn: Boolean
-case class VariableLight(brightness: Int)
-case class VariableLightAdapter(light: VariableLight) extends Switchable:
-  def turnOn: Switchable = VariableLightAdapter(light.copy(brightness = 100))
-  def turnOff: Switchable = VariableLightAdapter(light.copy(brightness = 0))
-  def isOn: Boolean = light.brightness > 0
-```
-</details>
-<details>
-<summary>Haskell: newtype + 型クラスインスタンス</summary>
-```haskell
-class Switchable a where
-    turnOn  :: a -> a
-    turnOff :: a -> a
-    isOn    :: a -> Bool
-data VariableLight = VariableLight { brightness :: Int }
-newtype VariableLightAdapter = VariableLightAdapter VariableLight
-instance Switchable VariableLightAdapter where
-    turnOn (VariableLightAdapter _) =
-        VariableLightAdapter (VariableLight 100)
-    turnOff (VariableLightAdapter _) =
-        VariableLightAdapter (VariableLight 0)
-    isOn (VariableLightAdapter (VariableLight b)) = b > 0
-```
-`newtype` で既存の型をラップし、型クラスインスタンスを実装することで、コンパイル時のオーバーヘッドなしにアダプターを実現します。
-</details>
-<details>
-<summary>Rust: trait 実装</summary>
-```rust
-pub trait Switchable {
-    fn turn_on(&self) -> Box<dyn Switchable>;
-    fn turn_off(&self) -> Box<dyn Switchable>;
-    fn is_on(&self) -> bool;
-}
-pub struct VariableLight { pub brightness: u8 }
-pub struct VariableLightAdapter {
-    light: VariableLight,
-}
-impl Switchable for VariableLightAdapter {
-    fn turn_on(&self) -> Box<dyn Switchable> {
-        Box::new(VariableLightAdapter {
-            light: VariableLight { brightness: 100 },
-        })
-    }
-    fn turn_off(&self) -> Box<dyn Switchable> {
-        Box::new(VariableLightAdapter {
-            light: VariableLight { brightness: 0 },
-        })
-    }
-    fn is_on(&self) -> bool { self.light.brightness > 0 }
-}
-```
-</details>
-### 3.3 データ形式変換アダプター
-旧形式のユーザーデータを新形式に変換するアダプターです。
-<details>
-<summary>データ変換アダプターの比較</summary>
-```clojure
-;; Clojure: 変換関数
-(defn adapt-old-to-new [old-user]
-  {:id (:user-id old-user)
-   :full-name (str (:first-name old-user) " " (:last-name old-user))
-   :email (:email-address old-user)})
-```
-```scala
-// Scala: case class 変換
-case class OldUser(userId: String, firstName: String, lastName: String, emailAddress: String)
-case class NewUser(id: String, fullName: String, email: String)
-def adaptOldToNew(old: OldUser): NewUser =
-  NewUser(old.userId, s"${old.firstName} ${old.lastName}", old.emailAddress)
-```
-```fsharp
-// F#: レコード変換
-let adaptOldToNew (old: OldUser) : NewUser =
-    { Id = old.UserId
-      FullName = sprintf "%s %s" old.FirstName old.LastName
-      Email = old.EmailAddress }
-```
-```haskell
--- Haskell: 変換関数
-adaptOldToNew :: OldUser -> NewUser
-adaptOldToNew old = NewUser
-    { userId   = oldUserId old
-    , fullName = oldFirstName old ++ " " ++ oldLastName old
-    , email    = oldEmailAddress old
-    }
-```
-```rust
-// Rust: From trait
-impl From<OldUser> for NewUser {
-    fn from(old: OldUser) -> Self {
-        NewUser {
-            id: old.user_id,
-            full_name: format!("{} {}", old.first_name, old.last_name),
-            email: old.email_address,
-        }
-    }
-}
-// 使用: NewUser::from(old_user) or old_user.into()
-```
-Rust の `From` trait は標準ライブラリが提供するアダプターパターンの典型です。
-</details>
-### 3.4 双方向アダプター
-`A → B` と `B → A` の両方を提供するアダプターです。
-<details>
-<summary>双方向アダプターの比較</summary>
-```haskell
--- Haskell
-data Adapter a b = Adapter
-    { adapt   :: a -> b
-    , unadapt :: b -> a
-    }
-celsiusFahrenheit :: Adapter Double Double
-celsiusFahrenheit = Adapter
-    { adapt   = \c -> c * 9 / 5 + 32
-    , unadapt = \f -> (f - 32) * 5 / 9
-    }
-```
-```scala
-// Scala
-case class Adapter[A, B](adapt: A => B, unadapt: B => A)
-val celsiusFahrenheit = Adapter[Double, Double](
-  adapt   = c => c * 9.0 / 5 + 32,
-  unadapt = f => (f - 32) * 5.0 / 9
-)
-```
-```fsharp
-// F#
-type Adapter<'A, 'B> = { Adapt: 'A -> 'B; Unadapt: 'B -> 'A }
-let celsiusFahrenheit = {
-    Adapt = fun c -> c * 9.0 / 5.0 + 32.0
-    Unadapt = fun f -> (f - 32.0) * 5.0 / 9.0
-}
-```
-</details>
-## 4. 比較分析
-### 4.1 OOP Adapter vs 関数型 Adapter
-| 観点 | OOP | 関数型 |
-|------|-----|--------|
-| アダプター | ラッパークラス | 変換関数 |
-| インターフェース | Java/C# のインターフェース | 型クラス / trait / プロトコル |
-| ボイラープレート | 多い（委譲メソッド） | 少ない（関数のみ） |
-| 双方向 | 2 つのクラス | 関数のペア |
-| 合成 | 複雑 | `compose` / `>>` で合成 |
-### 4.2 Rust の From/Into trait
-Rust は標準ライブラリに `From` / `Into` trait を持ち、型変換のアダプターパターンを言語レベルでサポートしています。`From<A> for B` を実装すると、`Into<B> for A` が自動的に得られます。
-### 4.3 言語間のアダプター表現力
-| 基準 | 最適な言語 | 理由 |
-|------|----------|------|
-| 型安全な変換 | Haskell | newtype + 型クラスでゼロコスト |
-| 標準ライブラリ統合 | Rust | From/Into が標準提供 |
-| 柔軟な変換 | Clojure | マップ変換が自由自在 |
-| 既存型への後付け | Scala | extension メソッド / given |
-## 5. Elixir コラム：I/O と外部システム
-Elixir の第 9 章は Adapter パターンではなく、**I/O と外部システムの抽象化**を扱っています。
-### リポジトリパターン
-```elixir
-defmodule Repository do
-  use Agent
-  def start_link(_opts) do
-    Agent.start_link(fn -> %{} end, name: __MODULE__)
-  end
-  def save(id, entity) do
-    Agent.update(__MODULE__, &Map.put(&1, id, entity))
-  end
-  def find(id) do
-    Agent.get(__MODULE__, &Map.get(&1, id))
-  end
-end
-```
-### HTTP クライアントの抽象化
-```elixir
-defmodule HttpClient do
-  @callback get(String.t()) :: {:ok, map()} | {:error, term()}
-  @callback post(String.t(), map()) :: {:ok, map()} | {:error, term()}
-end
-defmodule RealHttpClient do
-  @behaviour HttpClient
-  def get(url), do: HTTPoison.get(url)
-  def post(url, body), do: HTTPoison.post(url, Jason.encode!(body))
-end
-defmodule MockHttpClient do
-  @behaviour HttpClient
-  def get(_url), do: {:ok, %{status: 200, body: "mock"}}
-  def post(_url, _body), do: {:ok, %{status: 201}}
-end
-```
-Adapter パターンの「インターフェース適応」は、Elixir では `@behaviour` と `@callback` による**振る舞いの契約**として表現されます。テスト時にモック実装を差し替えることで、外部システムへの依存を分離します。
-## 6. まとめ
-Adapter パターンは、関数型プログラミングで**変換関数**として最も簡潔に表現されます：
-1. **関数がアダプター**: 型 A から型 B への変換関数
-2. **型クラス / trait / プロトコル**: 既存の型に新しいインターフェースを後付け
-3. **合成可能性**: 複数のアダプターをパイプラインで連鎖
-## 言語別個別記事
-- [Clojure](../clojure/09-adapter-pattern.md) | [Scala](../scala/09-adapter-pattern.md) | [Elixir](../elixir/09-io-and-external-systems.md) | [F#](../fsharp/09-adapter-pattern.md) | [Haskell](../haskell/09-adapter-pattern.md) | [Rust](../rust/09-adapter-pattern.md)

package/lib/assets/docs/article/functional-desgin-ppp/all/10-strategy-pattern.md DELETED Viewed

@@ -1,312 +0,0 @@
----
-type: Article
-title: "第10章: Strategy パターン — 6言語統合ガイド"
-description: "Strategy パターンは、アルゴリズムをカプセル化し、実行時に切り替えるための GoF パターンです。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第10章: Strategy パターン — 6言語統合ガイド
-## 1. はじめに
-Strategy パターンは、アルゴリズムをカプセル化し、実行時に切り替えるための GoF パターンです。OOP ではインターフェースと実装クラスで表現しますが、関数型プログラミングでは**関数そのものが戦略**です。高階関数を使えば、戦略の切り替えは関数の引数を変えるだけで実現できます。
-> **Elixir の読者へ**: Elixir 版は本章で「並行処理パターン」を扱っています。Elixir 固有のアクターモデルについては[コラム](#elixir-コラム並行処理パターン)を参照してください。
-## 2. 共通の本質
-### Strategy の構造
-```
-Context(strategy) → strategy(data) → result
-```
-OOP では Strategy インターフェースを実装するクラスを注入しますが、関数型では**関数を直接渡す**だけです。
-### 典型的なユースケース
-- **料金計算**: 通常・割引・会員・まとめ買い
-- **ソートアルゴリズム**: バブル・クイック・マージ
-- **フォーマット出力**: JSON・XML・CSV
-- **配送料計算**: 通常・エクスプレス・無料
-## 3. 言語別実装比較
-### 3.1 戦略の表現方法
-| 言語 | 戦略の表現 | コンテキストへの注入 |
-|------|----------|-----------------|
-| Clojure | 関数 / マルチメソッド | 引数として渡す |
-| Scala | trait / 関数リテラル | 型パラメータ / 引数 |
-| F# | 判別共用体 / 関数 | パイプライン / 引数 |
-| Haskell | newtype でラップした関数 | 引数として渡す |
-| Rust | trait object / クロージャ | ジェネリクス / `Box<dyn Fn>` |
-### 3.2 料金計算の Strategy
-<details>
-<summary>Clojure: 関数ベースの戦略</summary>
-```clojure
-;; 戦略 = 単なる関数
-(defn regular-pricing [amount] amount)
-(defn discount-pricing [rate]
-  (fn [amount] (* amount (- 1 rate))))
-(defn member-pricing [amount]
-  (* amount 0.9))
-(defn bulk-pricing [threshold discount-rate]
-  (fn [amount]
-    (if (>= amount threshold)
-      (* amount (- 1 discount-rate))
-      amount)))
-;; コンテキスト
-(defn calculate-total [items pricing-strategy]
-  (let [subtotal (reduce + (map :price items))]
-    (pricing-strategy subtotal)))
-;; 使用
-(calculate-total items (discount-pricing 0.2))
-```
-</details>
-<details>
-<summary>Scala: trait + 関数型ハイブリッド</summary>
-```scala
-// trait ベース
-trait PricingStrategy:
-  def calculate(amount: Double): Double
-object RegularPricing extends PricingStrategy:
-  def calculate(amount: Double): Double = amount
-class DiscountPricing(rate: Double) extends PricingStrategy:
-  def calculate(amount: Double): Double = amount * (1 - rate)
-// 関数ベース（より簡潔）
-type PricingFn = Double => Double
-val regular: PricingFn = identity
-def discount(rate: Double): PricingFn = _ * (1 - rate)
-def bulk(threshold: Double, rate: Double): PricingFn =
-  amount => if amount >= threshold then amount * (1 - rate) else amount
-// 戦略の合成
-def compose(strategies: PricingFn*): PricingFn =
-  strategies.reduce(_ andThen _)
-```
-</details>
-<details>
-<summary>Haskell: newtype + モノイド</summary>
-```haskell
-newtype PricingStrategy = PricingStrategy { runStrategy :: Double -> Double }
-regularPricing :: PricingStrategy
-regularPricing = PricingStrategy id
-discountPricing :: Double -> PricingStrategy
-discountPricing rate = PricingStrategy (\amount -> amount * (1 - rate))
-memberPricing :: PricingStrategy
-memberPricing = PricingStrategy (\amount -> amount * 0.9)
--- 戦略の合成（モノイド）
-composeStrategies :: [PricingStrategy] -> PricingStrategy
-composeStrategies = PricingStrategy . foldr ((.) . runStrategy) id
--- コンテキスト
-calculateTotal :: PricingStrategy -> [Item] -> Double
-calculateTotal strategy items =
-    runStrategy strategy (sum (map itemPrice items))
-```
-Haskell では戦略を `newtype` でラップし、モノイドとして合成可能にしています。
-</details>
-<details>
-<summary>F#: 判別共用体 + 関数</summary>
-```fsharp
-// 判別共用体版
-type PricingStrategy =
-    | Regular
-    | Discount of rate: float
-    | Member
-    | Bulk of threshold: float * rate: float
-let applyStrategy (strategy: PricingStrategy) (amount: float) : float =
-    match strategy with
-    | Regular -> amount
-    | Discount rate -> amount * (1.0 - rate)
-    | Member -> amount * 0.9
-    | Bulk(threshold, rate) ->
-        if amount >= threshold then amount * (1.0 - rate) else amount
-// 関数版（より柔軟）
-module FunctionalStrategy =
-    let regular: float -> float = id
-    let discount rate amount = amount * (1.0 - rate)
-    let conditional pred strategy amount =
-        if pred amount then strategy amount else amount
-```
-</details>
-<details>
-<summary>Rust: trait + クロージャ</summary>
-```rust
-// trait ベース
-pub trait PricingStrategy {
-    fn calculate(&self, amount: f64) -> f64;
-}
-pub struct RegularPricing;
-impl PricingStrategy for RegularPricing {
-    fn calculate(&self, amount: f64) -> f64 { amount }
-}
-pub struct DiscountPricing { pub rate: f64 }
-impl PricingStrategy for DiscountPricing {
-    fn calculate(&self, amount: f64) -> f64 {
-        amount * (1.0 - self.rate)
-    }
-}
-// クロージャベース（より簡潔）
-pub fn calculate_total(
-    items: &[Item],
-    strategy: impl Fn(f64) -> f64,
-) -> f64 {
-    let subtotal: f64 = items.iter().map(|i| i.price).sum();
-    strategy(subtotal)
-}
-// 使用
-calculate_total(&items, |amount| amount * 0.8);
-```
-</details>
-### 3.3 戦略の合成
-複数の戦略を組み合わせて新しい戦略を作るパターンです。
-| 言語 | 合成方法 | 例 |
-|------|---------|-----|
-| Clojure | `comp` | `(comp member-pricing (discount-pricing 0.1))` |
-| Scala | `andThen` | `discount(0.1) andThen bulk(1000, 0.05)` |
-| F# | `>>` | `discount 0.1 >> member` |
-| Haskell | `.` | `runStrategy memberPricing . runStrategy (discountPricing 0.1)` |
-| Rust | クロージャチェーン | `\|amount\| bulk(1000, 0.05, discount(0.1, amount))` |
-### 3.4 条件付き戦略
-実行時の条件に応じて戦略を選択するパターンです。
-```clojure
-;; Clojure
-(defn select-strategy [customer-type]
-  (case customer-type
-    :regular regular-pricing
-    :member member-pricing
-    :vip    (discount-pricing 0.3)))
-```
-```scala
-// Scala
-def selectStrategy(customerType: CustomerType): PricingFn =
-  customerType match
-    case Regular => regular
-    case Member  => discount(0.1)
-    case VIP     => discount(0.3)
-```
-## 4. 比較分析
-### 4.1 OOP Strategy vs 関数型 Strategy
-| 観点 | OOP | 関数型 |
-|------|-----|--------|
-| 戦略の定義 | クラス | 関数 |
-| 注入方法 | コンストラクタ / セッター | 関数引数 |
-| 合成 | Composite パターン | 関数合成 |
-| 状態 | フィールドに保持 | クロージャでキャプチャ |
-| ボイラープレート | 多い（インターフェース + 実装クラス） | 少ない（関数のみ） |
-### 4.2 trait/型クラス版 vs 関数版
-静的型付け言語（Scala, Rust）では、trait/型クラス版と関数版の 2 つのアプローチを並列して提示しています：
-- **trait/型クラス版**: 名前付きで文書化しやすく、複数メソッドの戦略に適する
-- **関数版**: 簡潔で、単一の振る舞いの切り替えに適する
-## 5. Elixir コラム：並行処理パターン
-Elixir の第 10 章は Strategy パターンではなく、**並行処理パターン**を扱っています。Elixir/Erlang の BEAM VM は軽量プロセスとメッセージパッシングを基盤とし、GoF の Strategy とは異なるアプローチで「振る舞いの切り替え」を実現します。
-### アクターモデルの基礎
-```elixir
-# プロセス間のメッセージパッシング
-defmodule Counter do
-  use Agent
-  def start_link(initial) do
-    Agent.start_link(fn -> initial end, name: __MODULE__)
-  end
-  def increment, do: Agent.update(__MODULE__, &(&1 + 1))
-  def value, do: Agent.get(__MODULE__, & &1)
-end
-```
-### GenServer による状態管理
-```elixir
-defmodule BankAccount do
-  use GenServer
-  def init(balance), do: {:ok, balance}
-  def handle_call(:balance, _from, balance) do
-    {:reply, balance, balance}
-  end
-  def handle_cast({:deposit, amount}, balance) do
-    {:noreply, balance + amount}
-  end
-end
-```
-### Task による非同期処理
-```elixir
-tasks = Enum.map(urls, fn url ->
-  Task.async(fn -> fetch(url) end)
-end)
-results = Enum.map(tasks, &Task.await/1)
-```
-Strategy パターンの「振る舞いの切り替え」は、Elixir ではプロセスの切り替えやメッセージパッシングのパターンとして表現されます。
-## 6. まとめ
-Strategy パターンは、関数型プログラミングで**最もシンプルに表現される** GoF パターンの一つです：
-1. **関数が戦略**: 高階関数の引数として戦略を渡すだけ
-2. **関数合成で戦略合成**: `comp` / `andThen` / `>>` / `.` で自然に合成
-3. **クロージャで状態管理**: パラメータ化された戦略はクロージャで表現
-## 言語別個別記事
-- [Clojure](../clojure/10-strategy-pattern.md) | [Scala](../scala/10-strategy-pattern.md) | [Elixir](../elixir/10-concurrency-patterns.md) | [F#](../fsharp/10-strategy-pattern.md) | [Haskell](../haskell/10-strategy-pattern.md) | [Rust](../rust/10-strategy-pattern.md)