@k2works/claude-code-booster 3.0.0 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/rust/22-oo-to-fp-migration.md

@@ -0,0 +1,349 @@
+# 第22章: OO から FP への移行
+
+## はじめに
+
+本章では、オブジェクト指向（OO）スタイルのコードを関数型（FP）スタイルに移行する方法を学びます。Rust はデフォルトで不変なため、FP スタイルに自然に適合しますが、OO から来た開発者のために移行のガイドラインを示します。
+
+## 1. OO スタイル vs FP スタイル
+
+### OO スタイル（可変）
+
+```rust
+/// OO スタイル: 内部状態を持つオブジェクト
+pub mod oo_style {
+    pub struct Account {
+        id: String,
+        balance: f64,
+        transactions: Vec<Transaction>,
+    }
+
+    pub struct Transaction {
+        pub transaction_type: TransactionType,
+        pub amount: f64,
+    }
+
+    pub enum TransactionType {
+        Deposit,
+        Withdrawal,
+    }
+
+    impl Account {
+        pub fn new(id: &str, initial_balance: f64) -> Account {
+            Account {
+                id: id.to_string(),
+                balance: initial_balance,
+                transactions: Vec::new(),
+            }
+        }
+
+        // 可変メソッド - 内部状態を変更
+        pub fn deposit(&mut self, amount: f64) -> f64 {
+            if amount > 0.0 {
+                self.balance += amount;
+                self.transactions.push(Transaction {
+                    transaction_type: TransactionType::Deposit,
+                    amount,
+                });
+            }
+            self.balance
+        }
+
+        pub fn withdraw(&mut self, amount: f64) -> f64 {
+            if amount > 0.0 && self.balance >= amount {
+                self.balance -= amount;
+                self.transactions.push(Transaction {
+                    transaction_type: TransactionType::Withdrawal,
+                    amount,
+                });
+            }
+            self.balance
+        }
+    }
+}
+```
+
+### FP スタイル（不変）
+
+```rust
+/// FP スタイル: 不変データと純粋関数
+pub mod fp_style {
+    #[derive(Debug, Clone)]
+    pub struct Account {
+        pub id: String,
+        pub balance: f64,
+        pub transactions: Vec<Transaction>,
+    }
+
+    #[derive(Debug, Clone)]
+    pub struct Transaction {
+        pub transaction_type: TransactionType,
+        pub amount: f64,
+    }
+
+    #[derive(Debug, Clone)]
+    pub enum TransactionType {
+        Deposit,
+        Withdrawal,
+    }
+
+    /// 口座を作成（純粋関数）
+    pub fn make_account(id: &str, initial_balance: f64) -> Account {
+        Account {
+            id: id.to_string(),
+            balance: initial_balance,
+            transactions: Vec::new(),
+        }
+    }
+
+    /// 入金（新しい口座を返す - 元は不変）
+    pub fn deposit(account: Account, amount: f64) -> Account {
+        if amount > 0.0 {
+            Account {
+                balance: account.balance + amount,
+                transactions: {
+                    let mut txns = account.transactions;
+                    txns.push(Transaction {
+                        transaction_type: TransactionType::Deposit,
+                        amount,
+                    });
+                    txns
+                },
+                ..account
+            }
+        } else {
+            account
+        }
+    }
+
+    /// 出金（新しい口座を返す - 元は不変）
+    pub fn withdraw(account: Account, amount: f64) -> Account {
+        if amount > 0.0 && account.balance >= amount {
+            Account {
+                balance: account.balance - amount,
+                transactions: {
+                    let mut txns = account.transactions;
+                    txns.push(Transaction {
+                        transaction_type: TransactionType::Withdrawal,
+                        amount,
+                    });
+                    txns
+                },
+                ..account
+            }
+        } else {
+            account
+        }
+    }
+}
+```
+
+## 2. 移行戦略
+
+### Strangler Fig パターン
+
+既存のコードを徐々に新しいスタイルに置き換えます。
+
+```rust
+pub mod migration {
+    use super::fp_style::*;
+
+    pub enum Style {
+        FP,
+        OO,
+    }
+
+    pub struct StranglerAccount {
+        pub style: Style,
+        pub data: Account,
+    }
+
+    /// フィーチャーフラグによる切り替え
+    pub fn create_account(id: &str, balance: f64, use_fp: bool) -> StranglerAccount {
+        let style = if use_fp { Style::FP } else { Style::OO };
+        StranglerAccount {
+            style,
+            data: make_account(id, balance),
+        }
+    }
+
+    /// 統一インターフェース
+    pub fn account_deposit(account: StranglerAccount, amount: f64) -> StranglerAccount {
+        StranglerAccount {
+            data: deposit(account.data, amount),
+            ..account
+        }
+    }
+}
+```
+
+### アダプターパターン
+
+既存のインターフェースを維持しながら、内部をFPに移行します。
+
+```rust
+pub mod adapter {
+    use super::fp_style::*;
+
+    /// 既存インターフェースを維持するアダプター
+    pub struct FPAccountAdapter {
+        account: Account,
+    }
+
+    impl FPAccountAdapter {
+        pub fn new(id: &str, initial_balance: f64) -> FPAccountAdapter {
+            FPAccountAdapter {
+                account: make_account(id, initial_balance),
+            }
+        }
+
+        pub fn get_balance(&self) -> f64 {
+            self.account.balance
+        }
+
+        // 既存のインターフェースを維持
+        pub fn deposit_to_account(&mut self, amount: f64) -> f64 {
+            self.account = deposit(self.account.clone(), amount);
+            self.account.balance
+        }
+
+        pub fn withdraw_from_account(&mut self, amount: f64) -> f64 {
+            self.account = withdraw(self.account.clone(), amount);
+            self.account.balance
+        }
+    }
+}
+```
+
+## 3. 多態性の実現
+
+### OO: トレイトオブジェクト
+
+```rust
+pub trait Shape {
+    fn area(&self) -> f64;
+}
+
+struct Circle { radius: f64 }
+struct Rectangle { width: f64, height: f64 }
+
+impl Shape for Circle {
+    fn area(&self) -> f64 { std::f64::consts::PI * self.radius * self.radius }
+}
+
+impl Shape for Rectangle {
+    fn area(&self) -> f64 { self.width * self.height }
+}
+```
+
+### FP: enum とパターンマッチ
+
+```rust
+pub enum Shape {
+    Circle { radius: f64 },
+    Rectangle { width: f64, height: f64 },
+    Triangle { base: f64, height: f64 },
+}
+
+pub fn area(shape: &Shape) -> f64 {
+    match shape {
+        Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
+        Shape::Rectangle { width, height } => width * height,
+        Shape::Triangle { base, height } => base * height / 2.0,
+    }
+}
+
+pub fn scale(shape: &Shape, factor: f64) -> Shape {
+    match shape {
+        Shape::Circle { radius } => Shape::Circle { radius: radius * factor },
+        Shape::Rectangle { width, height } => Shape::Rectangle {
+            width: width * factor,
+            height: height * factor,
+        },
+        Shape::Triangle { base, height } => Shape::Triangle {
+            base: base * factor,
+            height: height * factor,
+        },
+    }
+}
+```
+
+## 4. 段階的な関数抽出
+
+```rust
+/// 純粋関数を抽出
+pub fn calculate_interest(balance: f64, rate: f64, days: i32) -> f64 {
+    balance * rate * (days as f64 / 365.0)
+}
+
+/// 手数料計算（純粋関数）
+pub struct FeeStructure {
+    pub minimum_balance: f64,
+    pub low_balance_fee: f64,
+    pub premium_threshold: f64,
+    pub standard_fee: f64,
+}
+
+pub fn calculate_fee(balance: f64, fee_structure: &FeeStructure) -> f64 {
+    if balance < fee_structure.minimum_balance {
+        fee_structure.low_balance_fee
+    } else if balance > fee_structure.premium_threshold {
+        0.0
+    } else {
+        fee_structure.standard_fee
+    }
+}
+```
+
+## 5. OO vs FP 比較表
+
+| 側面 | OO | FP |
+|------|----|----|
+| 基本単位 | オブジェクト | データ + 関数 |
+| 状態管理 | 可変（mutable） | 不変（immutable） |
+| 多態性 | 継承・トレイト | ADT・パターンマッチ |
+| コード再利用 | 継承 | 関数合成 |
+| 副作用 | どこでも可能 | 境界に分離 |
+| テスト | モックが必要 | 入力→出力のみ |
+| デバッグ | 状態追跡が困難 | 値が不変で追跡容易 |
+| 並行処理 | ロックが必要 | 不変データで安全 |
+
+## 6. 移行チェックリスト
+
+### 準備
+
+- [ ] 現在のコードの状態を把握
+- [ ] テストカバレッジを確認
+- [ ] 移行の優先順位を決定
+
+### 実行
+
+- [ ] 純粋関数を抽出
+- [ ] 副作用を分離
+- [ ] ADT に移行
+- [ ] テストを追加
+
+### 完了
+
+- [ ] 古いコードを削除
+- [ ] ドキュメントを更新
+- [ ] パフォーマンスを確認
+
+## まとめ
+
+本章では、OO から FP への移行について学びました：
+
+1. **OO vs FP**: 可変 vs 不変の違い
+2. **Strangler Fig パターン**: 段階的な移行
+3. **アダプターパターン**: 既存インターフェースの維持
+4. **ADT への移行**: enum とパターンマッチ
+5. **純粋関数の抽出**: ビジネスロジックの分離
+
+Rust は不変性がデフォルトなので、FP スタイルへの移行は自然に行えます。
+
+## 参考コード
+
+- ソースコード: `apps/rust/part7/src/chapter22.rs`
+
+---
+
+**Simple made easy.**

package/lib/assets/docs/article/functional-desgin-ppp/rust/index.md

@@ -0,0 +1,199 @@
+# Rust で学ぶ関数型デザイン
+
+## はじめに
+
+本記事シリーズは、関数型プログラミングにおける設計原則とデザインパターンを Rust を使って実践的に学ぶためのガイドです。Rust の所有権システムと型システムを活かし、従来のデザインパターンを関数型パラダイムでどのように表現し、活用できるかを探求します。
+
+## 記事構成
+
+### 第1部: 関数型プログラミングの基礎原則
+
+1. [不変性とデータ変換](./01-immutability-and-data-transformation.md)
+    - デフォルトの不変性と所有権
+    - イテレータとデータ変換パイプライン
+    - 副作用の分離
+
+2. [関数合成と高階関数](./02-function-composition.md)
+    - クロージャによる関数合成
+    - カリー化と部分適用
+    - 高階関数の活用
+
+3. [多態性の実現方法](./03-polymorphism.md)
+    - enum と代数的データ型
+    - trait による抽象化
+    - ジェネリクスと trait bounds
+
+### 第2部: 仕様とテスト
+
+4. [データ検証](./04-data-validation.md)
+    - 型によるバリデーション
+    - Result によるエラーハンドリング
+    - カスタムバリデータの作成
+
+5. [プロパティベーステスト](./05-property-based-testing.md)
+    - proptest の基本
+    - ジェネレータの作成
+    - プロパティの定義と検証
+
+6. [TDD と関数型プログラミング](./06-tdd-and-functional.md)
+    - Rust 組み込みテストの活用
+    - Red-Green-Refactor サイクル
+    - テストファーストの関数設計
+
+### 第3部: 構造パターン
+
+7. [Composite パターン](./07-composite-pattern.md)
+    - 再帰的なデータ構造
+    - enum によるツリー構造
+    - fold による走査
+
+8. [Decorator パターン](./08-decorator-pattern.md)
+    - 関数合成によるデコレーション
+    - クロージャでのラッピング
+    - 振る舞いの動的追加
+
+9. [Adapter パターン](./09-adapter-pattern.md)
+    - 関数アダプター
+    - プロトコル変換
+    - レガシーコードとの統合
+
+### 第4部: 振る舞いパターン
+
+10. [Strategy パターン](./10-strategy-pattern.md)
+    - クロージャとしての戦略
+    - 動的な戦略切り替え
+    - 戦略の合成
+
+11. [Command パターン](./11-command-pattern.md)
+    - 不変コマンド構造体
+    - コマンドの履歴と Undo
+    - マクロコマンド
+
+12. [Visitor パターン](./12-visitor-pattern.md)
+    - match によるパターンマッチ
+    - fold ベースのビジター
+    - 拡張可能なビジター
+
+### 第5部: 生成パターン
+
+13. [Abstract Factory パターン](./13-abstract-factory-pattern.md)
+    - 関数ファクトリー
+    - trait オブジェクトによる生成
+    - 依存性注入
+
+14. [Abstract Server パターン](./14-abstract-server-pattern.md)
+    - trait による抽象化
+    - 実装の差し替え
+    - テスタブルな設計
+
+### 第6部: ケーススタディ
+
+15. [ゴシップ好きなバスの運転手](./15-gossiping-bus-drivers.md)
+    - 不変状態の管理
+    - シミュレーションの実装
+    - 再帰的な処理
+
+16. [給与計算システム](./16-payroll-system.md)
+    - ドメインモデリング
+    - 多態的な計算
+    - レポート生成
+
+17. [レンタルビデオシステム](./17-video-rental-system.md)
+    - 状態遷移の管理
+    - イベントソーシング
+    - ビジネスルールの実装
+
+18. [並行処理システム](./18-concurrency-system.md)
+    - Mutex と RwLock による状態管理
+    - チャネルによるメッセージパッシング
+    - async/await と Tokio
+
+19. [Wa-Tor シミュレーション](./19-wator-simulation.md)
+    - セルオートマトン
+    - 不変グリッドの更新
+    - シミュレーションループ
+
+### 第7部: まとめと応用
+
+20. [パターン間の相互作用](./20-pattern-interactions.md)
+    - Composite + Decorator
+    - Command + Observer
+    - パターンの組み合わせ
+
+21. [ベストプラクティス](./21-best-practices.md)
+    - データ中心設計
+    - 所有権と借用の活用
+    - 関数デコレーター
+    - テスタブルな設計
+
+22. [OO から FP への移行](./22-oo-to-fp-migration.md)
+    - 移行戦略（Strangler Fig、アダプター）
+    - イベントソーシング
+    - 段階的な関数抽出
+    - enum による多態性
+
+---
+
+## 本シリーズの特徴
+
+### Rust の特性を活かした実装
+
+Rust の所有権システム、パターンマッチング、enum（代数的データ型）を活用し、安全かつ効率的な関数型プログラミングを学びます。
+
+### 実践重視
+
+すべてのパターンは Rust 組み込みのテストフレームワークによる実際に動作するテストコードを含みます。理論だけでなく、実装を通じて理解を深めることを重視しています。
+
+### 段階的な学習
+
+基礎から応用へと段階的に内容が進行します。各章は独立して読むこともできますが、順番に読むことでより深い理解が得られます。
+
+---
+
+## 対象読者
+
+- 関数型プログラミングに興味がある Rust 開発者
+- Rust を学習中の開発者
+- オブジェクト指向デザインパターンの知識があり、関数型での表現を学びたい開発者
+- Clojure 版や Scala 版と比較して学習したい開発者
+
+---
+
+## 前提知識
+
+- プログラミングの基礎知識
+- Rust の基本的な文法（struct、enum、trait、パターンマッチングなど）
+- デザインパターンの基本概念（推奨）
+
+---
+
+## 開発環境
+
+本シリーズのコードは以下の環境で動作確認しています：
+
+- Rust 1.75.0+
+- Cargo（Rust パッケージマネージャ）
+- proptest 1.4（プロパティベーステスト）
+- Nix による環境管理
+
+### 環境構築
+
+```bash
+# Nix を使用した開発環境の起動
+nix develop .#rust
+
+# テストの実行
+cd apps/rust/part1
+cargo test
+```
+
+---
+
+## 参考書籍
+
+本シリーズは以下の書籍の内容を参考にしています：
+
+- 「Functional Design: Principles, Patterns, and Practices」Robert C. Martin
+- 「Programming Rust」Jim Blandy, Jason Orendorff, Leonora F.S. Tindall
+- 「The Rust Programming Language」Steve Klabnik, Carol Nichols
+- 「Rust Design Patterns」