@k2works/claude-code-booster 3.0.0 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/all/15-gossiping-bus-drivers.md

@@ -0,0 +1,156 @@
+# 第15章: Gossiping Bus Drivers — 6言語統合ガイド
+
+## 1. はじめに
+
+Gossiping Bus Drivers は、バス運転手たちが停留所で出会うたびに噂を交換し、全員が同じ噂を共有するまでシミュレーションを続ける問題です。関数型プログラミングの**状態遷移**、**集合演算**、**無限シーケンス**を学ぶ格好の題材です。
+
+## 2. 共通の本質
+
+### 問題の構造
+
+1. 各運転手は固定のルートを**循環**する
+2. 同じ停留所にいる運転手同士が**噂を交換**する（集合の和）
+3. 全運転手が**同じ噂の集合**を持ったら終了
+4. 480 ステップ（1 日分）以内に収束しなければ「不可能」
+
+### 核となるアルゴリズム
+
+```
+ループ:
+  1. 各運転手の現在位置を計算（ルートの循環）
+  2. 同じ停留所にいる運転手をグループ化
+  3. 同一グループ内の噂を集合和で統合
+  4. 全員の噂が一致すれば終了
+```
+
+## 3. 言語別実装比較
+
+### 3.1 循環ルートの表現
+
+| 言語 | 実装方法 | 特徴 |
+|------|---------|------|
+| Clojure | `(cycle route)` | 遅延無限シーケンス |
+| Scala | `position % route.length` | 剰余演算 |
+| Elixir | `Stream.cycle(route)` | Stream ベース |
+| F# | `position % route.Length` | 剰余演算 |
+| Haskell | `cycle route` | 遅延無限リスト |
+| Rust | `current_index % stops.len()` | 剰余演算 |
+
+Clojure と Haskell は言語の遅延評価を活かし、`cycle` で無限シーケンスを直接生成します。他の言語は剰余演算で循環を表現します。
+
+<details>
+<summary>Clojure / Haskell: 遅延無限シーケンス</summary>
+
+```clojure
+;; Clojure: 無限列からn番目を取得
+(defn current-stop [driver step]
+  (nth (cycle (:route driver)) step))
+```
+
+```haskell
+-- Haskell: cycle で無限リスト
+currentStop :: Driver -> Int -> Stop
+currentStop driver step = cycle (driverRoute driver) !! step
+```
+
+</details>
+
+<details>
+<summary>Rust / Scala: 剰余演算</summary>
+
+```rust
+pub fn current_stop(&self, step: usize) -> &Stop {
+    &self.route.stops[step % self.route.stops.len()]
+}
+```
+
+```scala
+def currentStop(step: Int): Stop =
+  route(step % route.length)
+```
+
+</details>
+
+### 3.2 噂の交換（集合演算）
+
+| 言語 | 集合和の方法 |
+|------|-----------|
+| Clojure | `clojure.set/union` |
+| Scala | `rumors ++ otherRumors` |
+| Elixir | `MapSet.union(a, b)` |
+| F# | `Set.unionMany` |
+| Haskell | `Set.unions` |
+| Rust | `a.union(&b).cloned().collect()` |
+
+<details>
+<summary>噂交換の実装比較</summary>
+
+```clojure
+;; Clojure
+(defn share-rumors [drivers-at-stop]
+  (let [all-rumors (apply set/union (map :rumors drivers-at-stop))]
+    (map #(assoc % :rumors all-rumors) drivers-at-stop)))
+```
+
+```scala
+// Scala
+def shareRumors(drivers: Vector[Driver]): Vector[Driver] =
+  val allRumors = drivers.flatMap(_.rumors).toSet
+  drivers.map(_.copy(rumors = allRumors))
+```
+
+```elixir
+# Elixir
+def share_rumors(drivers) do
+  all_rumors = Enum.reduce(drivers, MapSet.new(), fn d, acc ->
+    MapSet.union(acc, d.rumors)
+  end)
+  Enum.map(drivers, &%{&1 | rumors: all_rumors})
+end
+```
+
+</details>
+
+### 3.3 状態管理のアプローチ
+
+| 言語 | 状態の扱い | 更新方法 |
+|------|----------|---------|
+| Clojure | 不変マップ | 新しいマップを返す |
+| Scala | case class | `copy` で新インスタンス |
+| Elixir | 不変構造体 | `%{struct \| field: value}` |
+| F# | 不変レコード | `{ record with field = value }` |
+| Haskell | 不変レコード | レコード更新構文 |
+| Rust | 可変 + Clone | `clone()` で新インスタンス |
+
+全言語が**不変の状態遷移**を基本とし、各ステップで新しいワールド状態を生成します。
+
+## 4. 比較分析
+
+### 4.1 遅延評価 vs 剰余演算
+
+- **遅延評価**（Clojure, Haskell）: 概念的に美しく、ルートが無限シーケンスとして自然に表現される
+- **剰余演算**（Scala, F#, Rust）: シンプルで効率的、メモリ使用量が予測可能
+
+### 4.2 集合演算の表現力
+
+Clojure と Haskell は集合演算が最も簡潔です。Rust は所有権システムのため `cloned().collect()` が必要になりますが、メモリ安全性が保証されます。
+
+## 5. 実践的な選択指針
+
+| 要件 | 推奨言語 | 理由 |
+|------|---------|------|
+| 概念的な明快さ | Clojure, Haskell | 遅延無限シーケンスが問題の本質に合致 |
+| パフォーマンス | Rust | ゼロコスト抽象化と所有権管理 |
+| 並行シミュレーション | Elixir | BEAM VM の並行処理が自然に拡張可能 |
+
+## 6. まとめ
+
+Gossiping Bus Drivers は、関数型プログラミングの 3 つの要素を統合的に学べる問題です：
+
+1. **循環データ**: 遅延シーケンス or 剰余演算
+2. **集合演算**: 噂の伝播は集合の和
+3. **状態遷移**: 各ステップが純粋関数
+
+## 言語別個別記事
+
+- [Clojure](../clojure/15-gossiping-bus-drivers.md) | [Scala](../scala/15-gossiping-bus-drivers.md) | [Elixir](../elixir/15-gossiping-bus-drivers.md) | [F#](../fsharp/15-gossiping-bus-drivers.md) | [Haskell](../haskell/15-gossiping-bus-drivers.md) | [Rust](../rust/15-gossiping-bus-drivers.md)

package/lib/assets/docs/article/functional-desgin-ppp/all/16-payroll-system.md

@@ -0,0 +1,178 @@
+# 第16章: 給与計算システム — 6言語統合ガイド
+
+## 1. はじめに
+
+給与計算システムは、**ドメインモデリング**と**多態的ディスパッチ**を実践的に学ぶためのケーススタディです。従業員の種類（時給制・月給制・歩合制）に応じた給与計算ロジックを、関数型パラダイムでどう設計するかを比較します。
+
+## 2. 共通の本質
+
+### ドメインモデル
+
+すべての言語で共通のドメイン概念：
+
+- **従業員分類**: 時給制（Hourly）、月給制（Salaried）、歩合制（Commissioned）
+- **支払いスケジュール**: 週次、月次、隔週
+- **支払い方法**: 銀行振込、小切手、手渡し
+- **計算ルール**: 残業（40 時間超）、歩合率、固定給
+
+### 計算ロジック
+
+```
+時給制:   通常時間 × 時給 + 残業時間 × 時給 × 1.5
+月給制:   固定月給
+歩合制:   基本給 + 売上 × 歩合率
+```
+
+## 3. 言語別実装比較
+
+### 3.1 従業員分類の型表現
+
+| 言語 | 型表現 | 多態性の方法 |
+|------|--------|-----------|
+| Clojure | マップ + キーワード | `defmulti` でディスパッチ |
+| Scala | `sealed trait` + `case class` | パターンマッチング |
+| Elixir | 構造体 + タプルタグ | パターンマッチング |
+| F# | 判別共用体 | パターンマッチング |
+| Haskell | 代数的データ型 | case 式 |
+| Rust | `enum` | `match` 式 |
+
+<details>
+<summary>Clojure: マップ + マルチメソッド</summary>
+
+```clojure
+(defmulti calculate-pay :pay-type)
+
+(defmethod calculate-pay :hourly [{:keys [hours hourly-rate]}]
+  (let [regular (min hours 40)
+        overtime (max 0 (- hours 40))]
+    (+ (* regular hourly-rate)
+       (* overtime hourly-rate 1.5))))
+
+(defmethod calculate-pay :salaried [{:keys [monthly-salary]}]
+  monthly-salary)
+
+(defmethod calculate-pay :commissioned [{:keys [base-salary sales commission-rate]}]
+  (+ base-salary (* sales commission-rate)))
+```
+
+</details>
+
+<details>
+<summary>Scala: sealed trait + パターンマッチ</summary>
+
+```scala
+sealed trait PayClassification
+case class Hourly(hourlyRate: Double) extends PayClassification
+case class Salaried(monthlySalary: Double) extends PayClassification
+case class Commissioned(baseSalary: Double, commissionRate: Double) extends PayClassification
+
+def calculatePay(classification: PayClassification, hours: Double, sales: Double): Double =
+  classification match
+    case Hourly(rate) =>
+      val regular = math.min(hours, 40)
+      val overtime = math.max(0, hours - 40)
+      regular * rate + overtime * rate * 1.5
+    case Salaried(salary) => salary
+    case Commissioned(base, rate) => base + sales * rate
+```
+
+</details>
+
+<details>
+<summary>Haskell: ADT + case 式</summary>
+
+```haskell
+data PayClassification
+    = Hourly Double
+    | Salaried Double
+    | Commissioned Double Double
+
+calculatePay :: PayClassification -> Double -> Double -> Double
+calculatePay classification hours sales = case classification of
+    Hourly rate ->
+        let regular = min hours 40
+            overtime = max 0 (hours - 40)
+        in regular * rate + overtime * rate * 1.5
+    Salaried salary -> salary
+    Commissioned base rate -> base + sales * rate
+```
+
+</details>
+
+<details>
+<summary>Rust: enum + match</summary>
+
+```rust
+pub enum PayClassification {
+    Hourly { hourly_rate: f64 },
+    Salaried { monthly_salary: f64 },
+    Commissioned { base_salary: f64, commission_rate: f64 },
+}
+
+impl PayClassification {
+    pub fn calculate(&self, hours: f64, sales: f64) -> f64 {
+        match self {
+            Self::Hourly { hourly_rate } => {
+                let regular = hours.min(40.0);
+                let overtime = (hours - 40.0).max(0.0);
+                regular * hourly_rate + overtime * hourly_rate * 1.5
+            }
+            Self::Salaried { monthly_salary } => *monthly_salary,
+            Self::Commissioned { base_salary, commission_rate } => {
+                base_salary + sales * commission_rate
+            }
+        }
+    }
+}
+```
+
+</details>
+
+### 3.2 データモデルの設計哲学
+
+| 言語 | 設計哲学 | データ定義 |
+|------|---------|----------|
+| Clojure | データ駆動 | マップリテラル、スキーマは Spec で後付け |
+| Scala | 型駆動 | case class 階層、コンパイル時チェック |
+| Elixir | データ駆動 | 構造体、タプルタグで分類 |
+| F# | 型駆動 | 判別共用体、コンパイル時網羅性チェック |
+| Haskell | 型駆動 | ADT、最も厳密な型チェック |
+| Rust | 型駆動 | enum、所有権 + 型安全性 |
+
+**動的型付け言語**（Clojure, Elixir）はデータ構造が柔軟で、新しいフィールドの追加が容易です。**静的型付け言語**（Scala, F#, Haskell, Rust）はコンパイル時にドメインルールの整合性を保証します。
+
+### 3.3 拡張性の違い
+
+新しい従業員分類（例: 日給制）を追加する場合：
+
+| 言語 | 変更箇所 | 安全性 |
+|------|---------|--------|
+| Clojure | `defmethod` を 1 つ追加 | テストで確認 |
+| Scala | case class 追加 + match に追加 | コンパイルエラーで検出 |
+| Elixir | 関数クローズを追加 | テストで確認 |
+| F# | 判別共用体に追加 + match に追加 | コンパイルエラーで検出 |
+| Haskell | ADT に追加 + case に追加 | コンパイルエラーで検出 |
+| Rust | enum に追加 + match に追加 | コンパイルエラーで検出 |
+
+## 4. 比較分析
+
+### ドメインモデリングのトレードオフ
+
+| 基準 | 動的型付け（Clojure, Elixir） | 静的型付け（Scala, F#, Haskell, Rust） |
+|------|---------------------------|-----------------------------------|
+| 柔軟性 | 高い（スキーマレス） | 型定義が必要 |
+| 安全性 | テストに依存 | コンパイル時チェック |
+| リファクタリング | リスクあり | コンパイラが支援 |
+| プロトタイピング | 高速 | 型設計が必要 |
+
+## 5. まとめ
+
+給与計算システムは、関数型言語でのドメインモデリングの典型例です：
+
+1. **多態的ディスパッチ**: 従業員分類ごとの計算を言語の多態性で表現
+2. **データと処理の分離**: データ定義と計算ロジックを明確に分離
+3. **拡張性**: 新しい分類の追加が既存コードへの影響を最小化
+
+## 言語別個別記事
+
+- [Clojure](../clojure/16-payroll-system.md) | [Scala](../scala/16-payroll-system.md) | [Elixir](../elixir/16-payroll-system.md) | [F#](../fsharp/16-payroll-system.md) | [Haskell](../haskell/16-payroll-system.md) | [Rust](../rust/16-payroll-system.md)

package/lib/assets/docs/article/functional-desgin-ppp/all/17-video-rental-system.md

@@ -0,0 +1,312 @@
+# 第17章: レンタルビデオシステム — 6言語統合ガイド
+
+## 1. はじめに
+
+レンタルビデオシステムは、Martin Fowler の「リファクタリング」で有名な例題を関数型で再設計するケーススタディです。映画のカテゴリ別料金計算、明細書のフォーマット出力、頻繁なルール変更への対応を通じて、**Strategy パターンの関数型実現**と**ドメインモデリング**を学びます。
+
+## 2. 共通の本質
+
+### ドメインモデル
+
+すべての言語で共通のドメイン概念：
+
+- **映画カテゴリ**: 通常（Regular）、新作（New Release）、子供向け（Children's）
+- **顧客**: 名前とレンタルのリストを保持
+- **レンタル**: 映画と貸出日数の組み合わせ
+- **明細書**: テキスト形式と HTML 形式の出力
+
+### 料金計算ルール
+
+```
+通常:     2日まで $2.0、3日目以降 $1.5/日
+新作:     $3.0/日（ボーナスポイント対象）
+子供向け: 3日まで $1.5、4日目以降 $1.5/日
+```
+
+### 設計上の課題
+
+1. **カテゴリ追加**: 新しい映画カテゴリへの対応
+2. **料金ルール変更**: ビジネスルールの頻繁な変更
+3. **出力形式追加**: テキスト以外のフォーマット対応
+
+## 3. 言語別実装比較
+
+### 3.1 映画カテゴリの型表現
+
+| 言語 | 型表現 | 特徴 |
+|------|--------|------|
+| Clojure | キーワード（`:regular`, `:new-release`, `:childrens`） | 動的、スキーマレス |
+| Scala | `enum MovieCategory` | 型安全、列挙 |
+| Elixir | アトム（`:regular`, `:new_release`, `:children`） | 動的、パターンマッチ向き |
+| F# | 判別共用体 `MovieType` | 網羅性チェック付き |
+| Haskell | ADT `Category` | 最も厳密な型チェック |
+| Rust | `enum PriceCode` | 型安全 + 所有権管理 |
+
+<details>
+<summary>Clojure: キーワード + マルチメソッド</summary>
+
+```clojure
+(defmulti determine-amount
+  (fn [r] (rental/get-movie-category r)))
+
+(defmethod determine-amount :regular [r]
+  (let [days (rental/get-days r)]
+    (if (> days 2) (+ 2.0 (* (- days 2) 1.5)) 2.0)))
+
+(defmethod determine-amount :new-release [r]
+  (* (rental/get-days r) 3.0))
+
+(defmethod determine-amount :childrens [r]
+  (let [days (rental/get-days r)]
+    (if (> days 3) (+ 1.5 (* (- days 3) 1.5)) 1.5)))
+```
+
+</details>
+
+<details>
+<summary>Scala: enum + パターンマッチ</summary>
+
+```scala
+enum MovieCategory:
+  case Regular
+  case NewRelease
+  case Childrens
+
+def calculateAmount(rental: Rental): Double =
+  rental.movie.category match
+    case MovieCategory.Regular =>
+      if rental.days > 2 then 2.0 + (rental.days - 2) * 1.5
+      else 2.0
+    case MovieCategory.NewRelease => rental.days * 3.0
+    case MovieCategory.Childrens =>
+      if rental.days > 3 then 1.5 + (rental.days - 3) * 1.5
+      else 1.5
+```
+
+</details>
+
+<details>
+<summary>Haskell: ADT + case 式</summary>
+
+```haskell
+data Category = Regular | NewRelease | Childrens deriving (Show, Eq)
+
+calculateAmount :: Rental -> Double
+calculateAmount rental = case movieCategory (rentalMovie rental) of
+    Regular ->
+        if days > 2 then 2.0 + fromIntegral (days - 2) * 1.5 else 2.0
+    NewRelease -> fromIntegral days * 3.0
+    Childrens ->
+        if days > 3 then 1.5 + fromIntegral (days - 3) * 1.5 else 1.5
+  where days = rentalDays rental
+```
+
+</details>
+
+<details>
+<summary>Rust: enum + match</summary>
+
+```rust
+#[derive(Debug, Clone, PartialEq)]
+pub enum PriceCode {
+    Regular,
+    NewRelease,
+    Children,
+}
+
+pub fn calculate_amount(rental: &Rental) -> Decimal {
+    match rental.movie.price_code {
+        PriceCode::Regular => {
+            if rental.days > 2 {
+                dec!(2.0) + Decimal::from(rental.days - 2) * dec!(1.5)
+            } else { dec!(2.0) }
+        }
+        PriceCode::NewRelease => Decimal::from(rental.days) * dec!(3.0),
+        PriceCode::Children => {
+            if rental.days > 3 {
+                dec!(1.5) + Decimal::from(rental.days - 3) * dec!(1.5)
+            } else { dec!(1.5) }
+        }
+    }
+}
+```
+
+</details>
+
+### 3.2 多態的ディスパッチの実現方法
+
+| 言語 | ディスパッチ方法 | 拡張性 |
+|------|----------------|--------|
+| Clojure | `defmulti` / `defmethod` | メソッド追加のみで拡張 |
+| Scala | パターンマッチ / trait object | `PricingPolicy` 追加で拡張 |
+| Elixir | `case` パターンマッチ | 句を追加 |
+| F# | `match` 式 | 判別共用体に追加 + コンパイラ警告 |
+| Haskell | `case` 式 | ADT に追加 + コンパイラ警告 |
+| Rust | `match` 式 / `trait` | enum に追加 + コンパイラエラー |
+
+Clojure のマルチメソッドは**オープンディスパッチ**（既存コードを変更せず拡張可能）を実現します。静的型付け言語は**閉じたディスパッチ**（型定義の変更が必要）ですが、コンパイラが未処理のケースを検出してくれます。
+
+### 3.3 明細書フォーマッターの設計
+
+| 言語 | フォーマッター設計 | 切り替え方法 |
+|------|------------------|-------------|
+| Clojure | マルチメソッド（`:text`, `:html`） | ディスパッチ値で選択 |
+| Scala | `StatementFormatter` trait | trait object を差し替え |
+| Elixir | 独立関数（`generate/1`, `generate_html/1`） | 関数を直接呼び分け |
+| F# | モジュール内関数（`formatText`, `formatHtml`） | 関数を直接呼び分け |
+| Haskell | `StatementFormat` enum | パターンマッチで選択 |
+| Rust | `StatementFormatter` trait | trait object を差し替え |
+
+<details>
+<summary>Clojure: マルチメソッドによるフォーマット切り替え</summary>
+
+```clojure
+(defmulti format-statement (fn [format _customer] format))
+
+(defmethod format-statement :text [_ customer]
+  (str "Rental Record for " (:name customer) "\n"
+       (apply str (map format-line-text (:rentals customer)))
+       "Amount owed is " (total-amount customer) "\n"))
+
+(defmethod format-statement :html [_ customer]
+  (str "<h1>Rental Record for " (:name customer) "</h1>\n"
+       "<ul>" (apply str (map format-line-html (:rentals customer))) "</ul>\n"))
+```
+
+</details>
+
+<details>
+<summary>Rust: trait による Strategy パターン</summary>
+
+```rust
+pub trait StatementFormatter {
+    fn format_header(&self, customer_name: &str) -> String;
+    fn format_line(&self, title: &str, amount: Decimal) -> String;
+    fn format_footer(&self, total: Decimal, points: i32) -> String;
+}
+
+pub struct TextFormatter;
+pub struct HtmlFormatter;
+
+impl StatementFormatter for TextFormatter {
+    fn format_header(&self, name: &str) -> String {
+        format!("Rental Record for {}\n", name)
+    }
+    // ...
+}
+```
+
+</details>
+
+### 3.4 ドメインモデルのデータ表現
+
+| 言語 | Customer | Rental | Movie | 不変性 |
+|------|----------|--------|-------|--------|
+| Clojure | マップ | マップ | マップ | 自動（永続データ構造） |
+| Scala | case class | case class | case class | `copy` で新インスタンス |
+| Elixir | 構造体 | 構造体 | 構造体 | `%{struct | field: value}` |
+| F# | レコード | レコード | レコード | `{ record with field = value }` |
+| Haskell | レコード | レコード | レコード | レコード更新構文 |
+| Rust | struct | struct | struct | `clone()` + 明示的 `mut` |
+
+<details>
+<summary>Scala: DSL によるビルダーパターン</summary>
+
+Scala 版は DSL（ドメイン固有言語）を用いた流暢な API を提供しています：
+
+```scala
+customer("John")
+  .rents(regular("Inception"), 3)
+  .rents(newRelease("New Movie"), 2)
+  .statement
+```
+
+このアプローチはテストコードの可読性を大幅に向上させます。
+
+</details>
+
+<details>
+<summary>Elixir: Agent ベースのリポジトリ</summary>
+
+Elixir 版は `Agent` を使ったステートフルなリポジトリパターンを採用しています：
+
+```elixir
+defmodule MovieRepository do
+  use Agent
+
+  def start_link(_opts) do
+    Agent.start_link(fn -> %{} end, name: __MODULE__)
+  end
+
+  def add(movie) do
+    Agent.update(__MODULE__, fn movies ->
+      Map.put(movies, movie.title, movie)
+    end)
+  end
+end
+```
+
+BEAM VM の並行処理モデルと自然に統合される設計です。
+
+</details>
+
+## 4. 比較分析
+
+### 4.1 OOP の Strategy パターンとの関係
+
+OOP では料金計算とフォーマットの切り替えに Strategy パターン（インターフェース + 実装クラス）を使います。関数型では各言語が異なるアプローチで同等の柔軟性を実現しています：
+
+| アプローチ | 言語 | OOP との対応 |
+|-----------|------|-------------|
+| マルチメソッド | Clojure | 最もオープンな戦略切り替え |
+| 高階関数 | Elixir, F# | 関数そのものが戦略 |
+| パターンマッチ | Scala, Haskell | データ型が戦略を内包 |
+| trait object | Rust, Scala | OOP に最も近い構造 |
+
+### 4.2 金銭計算の精度
+
+| 言語 | 数値型 | 精度 |
+|------|--------|------|
+| Clojure | `Double` | 浮動小数点 |
+| Scala | `Double` | 浮動小数点 |
+| Elixir | `Float` | 浮動小数点 |
+| F# | `decimal` | 10 進精度（.NET 統合） |
+| Haskell | `Double` | 浮動小数点 |
+| Rust | `rust_decimal::Decimal` | 10 進精度（外部クレート） |
+
+F# と Rust は金銭計算に適した 10 進精度型を使用しており、実務的な正確性を重視しています。
+
+### 4.3 拡張性の比較
+
+新しい映画カテゴリ（例: プレミアム）を追加する場合：
+
+| 言語 | 必要な変更 | 安全性 |
+|------|-----------|--------|
+| Clojure | `defmethod` を追加するだけ | テストで確認 |
+| Scala | enum + match に追加 | コンパイルエラーで検出 |
+| Elixir | `case` に句を追加 | テストで確認 |
+| F# | 判別共用体 + match に追加 | コンパイルエラーで検出 |
+| Haskell | ADT + case に追加 | コンパイルエラーで検出 |
+| Rust | enum + match に追加 | コンパイルエラーで検出 |
+
+## 5. 実践的な選択指針
+
+| 要件 | 推奨言語 | 理由 |
+|------|---------|------|
+| 頻繁なルール変更 | Clojure | マルチメソッドのオープンディスパッチ |
+| 金銭計算の精度 | F#, Rust | 10 進精度型のネイティブサポート |
+| DSL による可読性 | Scala | case class + ビルダーパターン |
+| 並行リポジトリ | Elixir | Agent による状態管理 |
+| 型安全な拡張 | Haskell | ADT + 網羅性チェック |
+
+## 6. まとめ
+
+レンタルビデオシステムは、OOP のリファクタリング例題を関数型で再設計する過程で、以下の学びを提供します：
+
+1. **Strategy パターンの関数型表現**: マルチメソッド、高階関数、パターンマッチによる戦略切り替え
+2. **ドメインモデルの型表現**: 動的タグ vs 代数的データ型 vs enum
+3. **フォーマッターの分離**: 計算ロジックと出力形式の明確な分離
+
+## 言語別個別記事
+
+- [Clojure](../clojure/17-video-rental-system.md) | [Scala](../scala/17-video-rental-system.md) | [Elixir](../elixir/17-video-rental-system.md) | [F#](../fsharp/17-video-rental-system.md) | [Haskell](../haskell/17-video-rental-system.md) | [Rust](../rust/17-video-rental-system.md)