@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/rust/10-strategy-pattern.md

@@ -0,0 +1,331 @@
+# 第10章: Strategy パターン
+
+## はじめに
+
+Strategy パターンは、アルゴリズムをカプセル化し、クライアントから独立して交換可能にするパターンです。関数型プログラミングでは、関数を第一級オブジェクトとして扱うことで、このパターンを自然に実現できます。
+
+本章では、ソート戦略、価格計算、フィルタリング、フォーマット戦略など、様々な例を通じて Strategy パターンの Rust での実装を学びます。
+
+## 1. パターンの構造
+
+```plantuml
+@startuml
+title Strategy パターン構造（Rust）
+
+interface "Strategy trait" as Strategy {
+  +execute(data): Result
+}
+
+class "Context" as Context {
+  +strategy: Box<dyn Strategy>
+  +execute_strategy(): Result
+}
+
+class "ConcreteStrategyA" as StrategyA
+class "ConcreteStrategyB" as StrategyB
+
+Strategy <|.. StrategyA
+Strategy <|.. StrategyB
+Context o-- Strategy
+@enduml
+```
+
+## 2. ソート戦略
+
+### トレイトベースの実装
+
+```rust
+/// ソート戦略トレイト
+pub trait SortStrategy<T> {
+    fn sort(&self, items: &mut Vec<T>);
+}
+
+/// 昇順ソート
+pub struct AscendingSort;
+
+impl<T: Ord> SortStrategy<T> for AscendingSort {
+    fn sort(&self, items: &mut Vec<T>) {
+        items.sort();
+    }
+}
+
+/// 降順ソート
+pub struct DescendingSort;
+
+impl<T: Ord> SortStrategy<T> for DescendingSort {
+    fn sort(&self, items: &mut Vec<T>) {
+        items.sort_by(|a, b| b.cmp(a));
+    }
+}
+
+/// カスタムソート
+pub struct CustomSort<T, F: Fn(&T, &T) -> std::cmp::Ordering> {
+    comparator: F,
+    _marker: std::marker::PhantomData<T>,
+}
+
+impl<T, F: Fn(&T, &T) -> std::cmp::Ordering> SortStrategy<T> for CustomSort<T, F> {
+    fn sort(&self, items: &mut Vec<T>) {
+        items.sort_by(&self.comparator);
+    }
+}
+```
+
+### 関数ベースの実装
+
+```rust
+/// ソート戦略（関数型）
+pub type SortFn<T> = Box<dyn Fn(&mut Vec<T>)>;
+
+pub fn ascending_sort<T: Ord + 'static>() -> SortFn<T> {
+    Box::new(|items| items.sort())
+}
+
+pub fn descending_sort<T: Ord + 'static>() -> SortFn<T> {
+    Box::new(|items| items.sort_by(|a, b| b.cmp(a)))
+}
+
+pub fn sort_by_key<T: 'static, K: Ord>(key_fn: impl Fn(&T) -> K + 'static) -> SortFn<T> {
+    Box::new(move |items| items.sort_by_key(|x| key_fn(x)))
+}
+```
+
+### 使用例
+
+```rust
+let mut numbers = vec![3, 1, 4, 1, 5, 9, 2, 6];
+
+// トレイトベース
+AscendingSort.sort(&mut numbers);
+assert_eq!(numbers, vec![1, 1, 2, 3, 4, 5, 6, 9]);
+
+// 関数ベース
+let sort_desc = descending_sort::<i32>();
+sort_desc(&mut numbers);
+assert_eq!(numbers, vec![9, 6, 5, 4, 3, 2, 1, 1]);
+```
+
+## 3. 価格計算戦略
+
+```rust
+/// 価格計算戦略
+pub trait PricingStrategy {
+    fn calculate(&self, base_price: f64) -> f64;
+}
+
+/// 通常価格
+pub struct RegularPricing;
+
+impl PricingStrategy for RegularPricing {
+    fn calculate(&self, base_price: f64) -> f64 {
+        base_price
+    }
+}
+
+/// 割引価格
+pub struct DiscountPricing {
+    pub discount_rate: f64,
+}
+
+impl PricingStrategy for DiscountPricing {
+    fn calculate(&self, base_price: f64) -> f64 {
+        base_price * (1.0 - self.discount_rate)
+    }
+}
+
+/// 会員価格
+pub struct MemberPricing {
+    pub member_discount: f64,
+    pub points_discount: f64,
+}
+
+impl PricingStrategy for MemberPricing {
+    fn calculate(&self, base_price: f64) -> f64 {
+        base_price * (1.0 - self.member_discount) - self.points_discount
+    }
+}
+
+/// 価格計算コンテキスト
+pub struct PriceCalculator {
+    strategy: Box<dyn PricingStrategy>,
+}
+
+impl PriceCalculator {
+    pub fn new(strategy: Box<dyn PricingStrategy>) -> Self {
+        PriceCalculator { strategy }
+    }
+
+    pub fn calculate(&self, base_price: f64) -> f64 {
+        self.strategy.calculate(base_price)
+    }
+}
+```
+
+### 使用例
+
+```rust
+let regular = PriceCalculator::new(Box::new(RegularPricing));
+assert_eq!(regular.calculate(100.0), 100.0);
+
+let discount = PriceCalculator::new(Box::new(DiscountPricing { discount_rate: 0.2 }));
+assert_eq!(discount.calculate(100.0), 80.0);
+
+let member = PriceCalculator::new(Box::new(MemberPricing {
+    member_discount: 0.1,
+    points_discount: 5.0,
+}));
+assert_eq!(member.calculate(100.0), 85.0);
+```
+
+## 4. フィルタリング戦略
+
+```rust
+/// フィルタ戦略
+pub type FilterFn<T> = Box<dyn Fn(&T) -> bool>;
+
+/// フィルタを合成
+pub fn and_filter<T: 'static>(
+    f1: FilterFn<T>,
+    f2: FilterFn<T>,
+) -> FilterFn<T> {
+    Box::new(move |item| f1(item) && f2(item))
+}
+
+pub fn or_filter<T: 'static>(
+    f1: FilterFn<T>,
+    f2: FilterFn<T>,
+) -> FilterFn<T> {
+    Box::new(move |item| f1(item) || f2(item))
+}
+
+pub fn not_filter<T: 'static>(f: FilterFn<T>) -> FilterFn<T> {
+    Box::new(move |item| !f(item))
+}
+```
+
+### 使用例
+
+```rust
+let is_positive: FilterFn<i32> = Box::new(|&x| x > 0);
+let is_even: FilterFn<i32> = Box::new(|&x| x % 2 == 0);
+
+let is_positive_and_even = and_filter(is_positive, is_even);
+
+let numbers = vec![-4, -2, 0, 2, 4, 6];
+let filtered: Vec<_> = numbers.iter().filter(|x| is_positive_and_even(x)).collect();
+assert_eq!(filtered, vec![&2, &4, &6]);
+```
+
+## 5. フォーマット戦略
+
+```rust
+/// フォーマット戦略
+pub trait FormatStrategy {
+    fn format(&self, data: &Data) -> String;
+}
+
+#[derive(Debug)]
+pub struct Data {
+    pub name: String,
+    pub value: f64,
+}
+
+/// JSON フォーマット
+pub struct JsonFormat;
+
+impl FormatStrategy for JsonFormat {
+    fn format(&self, data: &Data) -> String {
+        format!(r#"{{"name":"{}","value":{}}}"#, data.name, data.value)
+    }
+}
+
+/// XML フォーマット
+pub struct XmlFormat;
+
+impl FormatStrategy for XmlFormat {
+    fn format(&self, data: &Data) -> String {
+        format!(
+            "<data><name>{}</name><value>{}</value></data>",
+            data.name, data.value
+        )
+    }
+}
+
+/// CSV フォーマット
+pub struct CsvFormat;
+
+impl FormatStrategy for CsvFormat {
+    fn format(&self, data: &Data) -> String {
+        format!("{},{}", data.name, data.value)
+    }
+}
+```
+
+## 6. パターンの利点
+
+1. **柔軟性**: アルゴリズムを実行時に切り替え可能
+2. **分離**: アルゴリズムの実装と使用を分離
+3. **テスト容易性**: 各戦略を独立してテスト可能
+4. **拡張性**: 新しい戦略を簡単に追加可能
+
+## 7. Rust での特徴
+
+### クロージャによる簡潔な実装
+
+```rust
+// 関数として戦略を渡す
+fn process_with_strategy<T, F>(items: &[T], strategy: F) -> Vec<T>
+where
+    F: Fn(&T) -> T,
+    T: Clone,
+{
+    items.iter().map(|x| strategy(x)).collect()
+}
+
+// 使用
+let doubled = process_with_strategy(&[1, 2, 3], |x| x * 2);
+```
+
+### トレイトオブジェクト vs ジェネリクス
+
+```rust
+// トレイトオブジェクト（動的ディスパッチ）
+fn with_dyn(strategy: &dyn PricingStrategy, price: f64) -> f64 {
+    strategy.calculate(price)
+}
+
+// ジェネリクス（静的ディスパッチ）
+fn with_generic<S: PricingStrategy>(strategy: &S, price: f64) -> f64 {
+    strategy.calculate(price)
+}
+```
+
+## Scala との比較
+
+| 概念 | Scala | Rust |
+|------|-------|------|
+| 戦略定義 | trait | trait |
+| 関数戦略 | `A => B` | `Fn(A) -> B` |
+| 動的選択 | Any / type test | Box<dyn Trait> |
+| 合成 | andThen/compose | カスタム関数 |
+
+## まとめ
+
+本章では、Strategy パターンについて学びました：
+
+1. **ソート戦略**: 異なるソートアルゴリズムを切り替え
+2. **価格計算戦略**: 様々な価格計算ルールを適用
+3. **フィルタリング戦略**: フィルタを合成して複雑な条件を表現
+4. **フォーマット戦略**: 異なる出力形式に対応
+
+Rust では、トレイトとクロージャを組み合わせることで、型安全で柔軟な Strategy パターンを実現できます。
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/rust/part4/src/chapter10.rs`
+
+## 次章予告
+
+次章では、**Command パターン**について学びます。操作をオブジェクトとしてカプセル化する方法を探ります。

package/lib/assets/docs/article/functional-desgin-ppp/rust/11-command-pattern.md

@@ -0,0 +1,356 @@
+# 第11章: Command パターン
+
+## はじめに
+
+Command パターンは、操作をオブジェクトとしてカプセル化し、実行、取り消し、再実行を可能にするパターンです。関数型プログラミングでは、コマンドをデータとして表現し、純粋関数で操作を実行します。
+
+本章では、ドキュメント編集、グラフィックス操作、トランザクション処理など、様々な例を通じて Command パターンの Rust での実装を学びます。
+
+## 1. パターンの構造
+
+```plantuml
+@startuml
+title Command パターン構造（Rust）
+
+interface "Command trait" as Command {
+  +execute(state): State
+  +undo(state): State
+}
+
+class "Invoker" as Invoker {
+  +history: Vec<Box<dyn Command>>
+  +execute(cmd): State
+  +undo(): State
+}
+
+class "InsertCommand" as Insert
+class "DeleteCommand" as Delete
+
+Command <|.. Insert
+Command <|.. Delete
+Invoker o-- Command
+@enduml
+```
+
+## 2. ドキュメント編集コマンド
+
+### コマンドトレイト
+
+```rust
+/// ドキュメント状態
+#[derive(Debug, Clone, PartialEq)]
+pub struct Document {
+    pub content: String,
+    pub cursor: usize,
+}
+
+impl Document {
+    pub fn new() -> Document {
+        Document {
+            content: String::new(),
+            cursor: 0,
+        }
+    }
+}
+
+/// コマンドトレイト
+pub trait Command: CloneCommand {
+    fn execute(&self, doc: &Document) -> Document;
+    fn undo(&self, doc: &Document) -> Document;
+}
+
+/// コマンドを複製可能にするトレイト
+pub trait CloneCommand {
+    fn clone_box(&self) -> Box<dyn Command>;
+}
+
+impl<T: Command + Clone + 'static> CloneCommand for T {
+    fn clone_box(&self) -> Box<dyn Command> {
+        Box::new(self.clone())
+    }
+}
+```
+
+### 具体的なコマンド
+
+```rust
+/// テキスト挿入コマンド
+#[derive(Clone)]
+pub struct InsertCommand {
+    pub text: String,
+    pub position: usize,
+}
+
+impl Command for InsertCommand {
+    fn execute(&self, doc: &Document) -> Document {
+        let mut content = doc.content.clone();
+        content.insert_str(self.position, &self.text);
+        Document {
+            content,
+            cursor: self.position + self.text.len(),
+        }
+    }
+
+    fn undo(&self, doc: &Document) -> Document {
+        let mut content = doc.content.clone();
+        content.replace_range(self.position..self.position + self.text.len(), "");
+        Document {
+            content,
+            cursor: self.position,
+        }
+    }
+}
+
+/// テキスト削除コマンド
+#[derive(Clone)]
+pub struct DeleteCommand {
+    pub start: usize,
+    pub end: usize,
+    pub deleted_text: String,
+}
+
+impl Command for DeleteCommand {
+    fn execute(&self, doc: &Document) -> Document {
+        let mut content = doc.content.clone();
+        content.replace_range(self.start..self.end, "");
+        Document {
+            content,
+            cursor: self.start,
+        }
+    }
+
+    fn undo(&self, doc: &Document) -> Document {
+        let mut content = doc.content.clone();
+        content.insert_str(self.start, &self.deleted_text);
+        Document {
+            content,
+            cursor: self.start + self.deleted_text.len(),
+        }
+    }
+}
+```
+
+### コマンド履歴管理
+
+```rust
+/// コマンド履歴
+pub struct CommandHistory {
+    history: Vec<Box<dyn Command>>,
+    current: usize,
+}
+
+impl CommandHistory {
+    pub fn new() -> CommandHistory {
+        CommandHistory {
+            history: Vec::new(),
+            current: 0,
+        }
+    }
+
+    pub fn execute(&mut self, cmd: Box<dyn Command>, doc: &Document) -> Document {
+        // 現在位置以降の履歴を削除
+        self.history.truncate(self.current);
+        self.history.push(cmd.clone_box());
+        self.current += 1;
+        cmd.execute(doc)
+    }
+
+    pub fn undo(&mut self, doc: &Document) -> Option<Document> {
+        if self.current > 0 {
+            self.current -= 1;
+            Some(self.history[self.current].undo(doc))
+        } else {
+            None
+        }
+    }
+
+    pub fn redo(&mut self, doc: &Document) -> Option<Document> {
+        if self.current < self.history.len() {
+            let result = self.history[self.current].execute(doc);
+            self.current += 1;
+            Some(result)
+        } else {
+            None
+        }
+    }
+}
+```
+
+### 使用例
+
+```rust
+let mut doc = Document::new();
+let mut history = CommandHistory::new();
+
+// テキストを挿入
+let insert = InsertCommand {
+    text: "Hello".to_string(),
+    position: 0,
+};
+doc = history.execute(Box::new(insert), &doc);
+assert_eq!(doc.content, "Hello");
+
+// 元に戻す
+doc = history.undo(&doc).unwrap();
+assert_eq!(doc.content, "");
+
+// やり直す
+doc = history.redo(&doc).unwrap();
+assert_eq!(doc.content, "Hello");
+```
+
+## 3. マクロコマンド
+
+```rust
+/// 複数のコマンドをまとめて実行
+#[derive(Clone)]
+pub struct MacroCommand {
+    pub commands: Vec<Box<dyn Command>>,
+}
+
+impl Command for MacroCommand {
+    fn execute(&self, doc: &Document) -> Document {
+        self.commands
+            .iter()
+            .fold(doc.clone(), |d, cmd| cmd.execute(&d))
+    }
+
+    fn undo(&self, doc: &Document) -> Document {
+        self.commands
+            .iter()
+            .rev()
+            .fold(doc.clone(), |d, cmd| cmd.undo(&d))
+    }
+}
+```
+
+## 4. 関数型コマンド
+
+```rust
+/// 関数型コマンド
+pub type CommandFn<S> = Box<dyn Fn(&S) -> S>;
+
+/// コマンドを合成
+pub fn compose_commands<S: Clone + 'static>(
+    commands: Vec<CommandFn<S>>,
+) -> CommandFn<S> {
+    Box::new(move |state| {
+        commands.iter().fold(state.clone(), |s, cmd| cmd(&s))
+    })
+}
+
+/// 可逆コマンド
+pub struct ReversibleCommand<S> {
+    pub execute: Box<dyn Fn(&S) -> S>,
+    pub undo: Box<dyn Fn(&S) -> S>,
+}
+
+impl<S> ReversibleCommand<S> {
+    pub fn new<E, U>(execute: E, undo: U) -> Self
+    where
+        E: Fn(&S) -> S + 'static,
+        U: Fn(&S) -> S + 'static,
+    {
+        ReversibleCommand {
+            execute: Box::new(execute),
+            undo: Box::new(undo),
+        }
+    }
+}
+```
+
+## 5. トランザクションコマンド
+
+```rust
+/// トランザクション結果
+pub enum TransactionResult<T> {
+    Success(T),
+    Failure(String),
+    Rollback(T),
+}
+
+/// トランザクションコマンド
+pub struct TransactionCommand<S> {
+    pub commands: Vec<ReversibleCommand<S>>,
+}
+
+impl<S: Clone> TransactionCommand<S> {
+    pub fn execute(&self, state: &S) -> TransactionResult<S> {
+        let mut current = state.clone();
+        let mut executed = Vec::new();
+
+        for cmd in &self.commands {
+            let new_state = (cmd.execute)(&current);
+            executed.push(cmd);
+            current = new_state;
+        }
+
+        TransactionResult::Success(current)
+    }
+
+    pub fn rollback(&self, state: &S, executed: &[&ReversibleCommand<S>]) -> S {
+        executed
+            .iter()
+            .rev()
+            .fold(state.clone(), |s, cmd| (cmd.undo)(&s))
+    }
+}
+```
+
+## 6. パターンの利点
+
+1. **元に戻す/やり直す**: 操作の履歴を管理
+2. **遅延実行**: コマンドをキューに入れて後で実行
+3. **ログ記録**: 操作をログとして保存
+4. **トランザクション**: 複数の操作をアトミックに実行
+
+## 7. Rust での特徴
+
+### トレイトオブジェクトとクローン
+
+```rust
+// Box<dyn Command> をクローン可能にする
+pub trait CloneCommand {
+    fn clone_box(&self) -> Box<dyn Command>;
+}
+```
+
+### 所有権と不変性
+
+```rust
+// コマンドは状態を変更せず、新しい状態を返す
+fn execute(&self, doc: &Document) -> Document {
+    // doc は借用、新しい Document を返す
+}
+```
+
+## Scala との比較
+
+| 概念 | Scala | Rust |
+|------|-------|------|
+| コマンド定義 | case class | struct + trait |
+| 履歴管理 | List | Vec |
+| 不変更新 | copy() | Clone + 手動構築 |
+| 多態性 | trait | trait object |
+
+## まとめ
+
+本章では、Command パターンについて学びました：
+
+1. **ドキュメント編集**: 挿入、削除、置換コマンド
+2. **履歴管理**: Undo/Redo 機能
+3. **マクロコマンド**: 複数コマンドの合成
+4. **関数型コマンド**: 関数としてのコマンド
+5. **トランザクション**: アトミックな操作実行
+
+Rust では、トレイトオブジェクトと所有権システムを活用して、型安全なコマンドパターンを実現できます。
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/rust/part4/src/chapter11.rs`
+
+## 次章予告
+
+次章では、**Visitor パターン**について学びます。データ構造を走査して操作を適用する方法を探ります。