@k2works/claude-code-booster 6.2.0 → 6.3.0

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

@@ -1,165 +0,0 @@
----
-type: Article
-title: "第15章: Gossiping Bus Drivers — 6言語統合ガイド"
-description: "Gossiping Bus Drivers は、バス運転手たちが停留所で出会うたびに噂を交換し、全員が同じ噂を共有するまでシミュレーションを続ける問題です。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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

@@ -1,187 +0,0 @@
----
-type: Article
-title: "第16章: 給与計算システム — 6言語統合ガイド"
-description: "給与計算システムは、ドメインモデリングと多態的ディスパッチを実践的に学ぶためのケーススタディです。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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

@@ -1,321 +0,0 @@
----
-type: Article
-title: "第17章: レンタルビデオシステム — 6言語統合ガイド"
-description: "レンタルビデオシステムは、Martin Fowler の「リファクタリング」で有名な例題を関数型で再設計するケーススタディです。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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)