@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,336 @@
+# 第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

@@ -0,0 +1,303 @@
+# 第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)