@k2works/claude-code-booster 3.0.0 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/rust/08-decorator-pattern.md

@@ -0,0 +1,383 @@
+# 第8章: Decorator パターン
+
+## はじめに
+
+Decorator パターンは、既存のオブジェクトに新しい機能を動的に追加するパターンです。関数型プログラミングでは、高階関数を使って関数をラップし、横断的関心事（ロギング、キャッシング、タイミング計測など）を追加します。
+
+本章では、図形の操作履歴、関数のデコレーション、テキスト処理など、様々な例を通じて Decorator パターンの Rust での実装を学びます。
+
+## 1. パターンの構造
+
+```plantuml
+@startuml
+title Decorator パターン構造（Rust）
+
+interface "Shape trait" as Shape {
+  +translate(dx, dy): Self
+  +scale(factor): Self
+  +area(): f64
+}
+
+class "Circle" as Circle {
+  +center_x: f64
+  +center_y: f64
+  +radius: f64
+}
+
+class "JournaledShape<S>" as JournaledShape {
+  +shape: S
+  +journal: Vec<JournalEntry>
+  +translate(dx, dy): Self
+  +scale(factor): Self
+}
+
+Shape <|.. Circle
+Shape <|.. JournaledShape
+
+note right of JournaledShape
+  操作履歴を記録する
+  デコレータ
+end note
+@enduml
+```
+
+## 2. JournaledShape - 形状デコレータ
+
+### 基本実装
+
+```rust
+/// ジャーナルエントリ
+#[derive(Debug, Clone, PartialEq)]
+pub enum JournalEntry {
+    Translate { dx: f64, dy: f64 },
+    Scale { factor: f64 },
+    Rotate { angle: f64 },
+}
+
+/// 基本的な形状 trait
+pub trait Shape: Clone {
+    fn translate(&self, dx: f64, dy: f64) -> Self;
+    fn scale(&self, factor: f64) -> Self;
+    fn area(&self) -> f64;
+}
+
+/// 円
+#[derive(Debug, Clone, PartialEq)]
+pub struct Circle {
+    pub center_x: f64,
+    pub center_y: f64,
+    pub radius: f64,
+}
+
+impl Shape for Circle {
+    fn translate(&self, dx: f64, dy: f64) -> Circle {
+        Circle {
+            center_x: self.center_x + dx,
+            center_y: self.center_y + dy,
+            radius: self.radius,
+        }
+    }
+
+    fn scale(&self, factor: f64) -> Circle {
+        Circle {
+            center_x: self.center_x,
+            center_y: self.center_y,
+            radius: self.radius * factor,
+        }
+    }
+
+    fn area(&self) -> f64 {
+        std::f64::consts::PI * self.radius * self.radius
+    }
+}
+```
+
+### ジャーナル付き形状
+
+```rust
+/// 操作履歴を記録するデコレータ
+#[derive(Debug, Clone, PartialEq)]
+pub struct JournaledShape<S: Shape> {
+    pub shape: S,
+    pub journal: Vec<JournalEntry>,
+}
+
+impl<S: Shape> JournaledShape<S> {
+    pub fn new(shape: S) -> JournaledShape<S> {
+        JournaledShape {
+            shape,
+            journal: Vec::new(),
+        }
+    }
+
+    pub fn translate(&self, dx: f64, dy: f64) -> JournaledShape<S> {
+        JournaledShape {
+            shape: self.shape.translate(dx, dy),
+            journal: {
+                let mut j = self.journal.clone();
+                j.push(JournalEntry::Translate { dx, dy });
+                j
+            },
+        }
+    }
+
+    pub fn scale(&self, factor: f64) -> JournaledShape<S> {
+        JournaledShape {
+            shape: self.shape.scale(factor),
+            journal: {
+                let mut j = self.journal.clone();
+                j.push(JournalEntry::Scale { factor });
+                j
+            },
+        }
+    }
+
+    pub fn operation_count(&self) -> usize {
+        self.journal.len()
+    }
+}
+```
+
+### 使用例
+
+```rust
+let circle = Circle::new(0.0, 0.0, 10.0);
+let journaled = JournaledShape::new(circle);
+
+let moved = journaled.translate(5.0, 5.0);
+let scaled = moved.scale(2.0);
+
+assert_eq!(scaled.operation_count(), 2);
+assert_eq!(scaled.shape.radius, 20.0);
+```
+
+## 3. 関数デコレータ
+
+### ロギングデコレータ
+
+```rust
+/// ロギングデコレータ
+pub fn with_logging<A, B, F>(
+    f: F,
+    name: &str,
+    logs: Rc<RefCell<Vec<String>>>,
+) -> impl Fn(A) -> B
+where
+    F: Fn(A) -> B,
+    A: std::fmt::Debug,
+    B: std::fmt::Debug,
+{
+    let name = name.to_string();
+    move |arg: A| {
+        logs.borrow_mut()
+            .push(format!("{} called with {:?}", name, arg));
+        let result = f(arg);
+        logs.borrow_mut()
+            .push(format!("{} returned {:?}", name, result));
+        result
+    }
+}
+```
+
+### タイミングデコレータ
+
+```rust
+/// 実行時間を計測するデコレータ
+pub fn with_timing<A, B, F>(
+    f: F,
+    timings: Arc<Mutex<Vec<Duration>>>,
+) -> impl Fn(A) -> B
+where
+    F: Fn(A) -> B,
+{
+    move |arg: A| {
+        let start = Instant::now();
+        let result = f(arg);
+        let elapsed = start.elapsed();
+        timings.lock().unwrap().push(elapsed);
+        result
+    }
+}
+```
+
+### キャッシュデコレータ
+
+```rust
+/// 結果をキャッシュするデコレータ
+pub fn with_memoization<A, B, F>(f: F) -> impl Fn(A) -> B
+where
+    F: Fn(A) -> B,
+    A: Clone + std::hash::Hash + Eq,
+    B: Clone,
+{
+    let cache = Rc::new(RefCell::new(HashMap::new()));
+    move |arg: A| {
+        let mut cache = cache.borrow_mut();
+        if let Some(result) = cache.get(&arg) {
+            return result.clone();
+        }
+        let result = f(arg.clone());
+        cache.insert(arg, result.clone());
+        result
+    }
+}
+```
+
+### 使用例
+
+```rust
+// ロギング付き関数
+let logs = Rc::new(RefCell::new(Vec::new()));
+let add_one = |x: i32| x + 1;
+let logged_add = with_logging(add_one, "add_one", logs.clone());
+
+let result = logged_add(5);
+assert_eq!(result, 6);
+assert_eq!(logs.borrow().len(), 2);
+
+// メモ化付きフィボナッチ
+let fib = with_memoization(|n: u64| {
+    if n <= 1 { n } else { /* recursive call */ n }
+});
+```
+
+## 4. テキストデコレータ
+
+```rust
+/// テキスト変換タイプ
+pub type TextTransformer = Box<dyn Fn(&str) -> String>;
+
+/// 大文字変換
+pub fn uppercase() -> TextTransformer {
+    Box::new(|s: &str| s.to_uppercase())
+}
+
+/// トリム
+pub fn trim() -> TextTransformer {
+    Box::new(|s: &str| s.trim().to_string())
+}
+
+/// プレフィックス追加
+pub fn add_prefix(prefix: &str) -> TextTransformer {
+    let prefix = prefix.to_string();
+    Box::new(move |s: &str| format!("{}{}", prefix, s))
+}
+
+/// デコレータを合成
+pub fn compose_transformers(transformers: Vec<TextTransformer>) -> TextTransformer {
+    Box::new(move |s: &str| {
+        transformers
+            .iter()
+            .fold(s.to_string(), |acc, t| t(&acc))
+    })
+}
+```
+
+### 使用例
+
+```rust
+let transform = compose_transformers(vec![
+    trim(),
+    uppercase(),
+    add_prefix(">>> "),
+]);
+
+let result = transform("  hello world  ");
+assert_eq!(result, ">>> HELLO WORLD");
+```
+
+## 5. リトライデコレータ
+
+```rust
+/// リトライデコレータ
+pub fn with_retry<A, B, E, F>(
+    f: F,
+    max_retries: usize,
+) -> impl Fn(A) -> Result<B, E>
+where
+    F: Fn(A) -> Result<B, E>,
+    A: Clone,
+{
+    move |arg: A| {
+        let mut attempts = 0;
+        loop {
+            match f(arg.clone()) {
+                Ok(result) => return Ok(result),
+                Err(e) if attempts < max_retries => {
+                    attempts += 1;
+                    continue;
+                }
+                Err(e) => return Err(e),
+            }
+        }
+    }
+}
+```
+
+## 6. パターンの利点
+
+1. **関心の分離**: 本質的なロジックと横断的関心事を分離
+2. **再利用性**: デコレータを様々な関数/型に適用可能
+3. **合成可能**: 複数のデコレータを組み合わせ可能
+4. **テスト容易性**: 各デコレータを独立してテスト可能
+
+## 7. Rust での特徴
+
+### ジェネリクスとトレイト境界
+
+```rust
+pub fn with_logging<A, B, F>(f: F, ...) -> impl Fn(A) -> B
+where
+    F: Fn(A) -> B,
+    A: std::fmt::Debug,
+    B: std::fmt::Debug,
+```
+
+### クロージャによるカプセル化
+
+```rust
+// 状態をクロージャ内にキャプチャ
+let cache = Rc::new(RefCell::new(HashMap::new()));
+move |arg: A| {
+    // cache を使用
+}
+```
+
+### 所有権と借用
+
+```rust
+// Rc<RefCell<T>> で共有可変状態を管理
+let logs = Rc::new(RefCell::new(Vec::new()));
+let logged_fn = with_logging(f, "name", logs.clone());
+```
+
+## Scala との比較
+
+| 概念 | Scala | Rust |
+|------|-------|------|
+| 高階関数 | `(A => B) => (A => B)` | `Fn(A) -> B` |
+| 状態管理 | var / mutable collection | Rc<RefCell<T>> |
+| 型制約 | 暗黙的な型推論 | where 句でトレイト境界 |
+| クロージャ | 自動キャプチャ | move で所有権移動 |
+
+## まとめ
+
+本章では、Decorator パターンについて学びました：
+
+1. **JournaledShape**: 操作履歴を記録する図形デコレータ
+2. **ロギングデコレータ**: 関数呼び出しをログに記録
+3. **タイミングデコレータ**: 実行時間を計測
+4. **キャッシュデコレータ**: 結果をメモ化
+5. **テキストデコレータ**: 文字列変換の合成
+
+Rust では、ジェネリクス、トレイト境界、クロージャを組み合わせることで、型安全で柔軟なデコレータを実装できます。
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/rust/part3/src/chapter08.rs`
+
+## 次章予告
+
+次章では、**Adapter パターン**について学びます。異なるインターフェース間の変換方法を探ります。

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

@@ -0,0 +1,339 @@
+# 第9章: Adapter パターン
+
+## はじめに
+
+Adapter パターンは、互換性のないインターフェースを持つクラスを協調して動作させるパターンです。関数型プログラミングでは、データ変換関数を使って異なるデータ形式間の変換を行います。
+
+本章では、温度変換、データフォーマット変換、レガシーシステムとの統合など、様々な例を通じて Adapter パターンの Rust での実装を学びます。
+
+## 1. パターンの構造
+
+```plantuml
+@startuml
+title Adapter パターン構造（Rust）
+
+interface "Target" as Target {
+  +operation(): Result
+}
+
+class "Adaptee" as Adaptee {
+  +specific_operation(): OtherResult
+}
+
+class "Adapter" as Adapter {
+  +adaptee: Adaptee
+  +operation(): Result
+}
+
+Target <|.. Adapter
+Adapter o-- Adaptee
+
+note right of Adapter
+  Adaptee を Target の
+  インターフェースに適合させる
+end note
+@enduml
+```
+
+## 2. 温度変換アダプタ
+
+```rust
+/// 摂氏温度
+#[derive(Debug, Clone, PartialEq)]
+pub struct Celsius(pub f64);
+
+/// 華氏温度
+#[derive(Debug, Clone, PartialEq)]
+pub struct Fahrenheit(pub f64);
+
+/// ケルビン温度
+#[derive(Debug, Clone, PartialEq)]
+pub struct Kelvin(pub f64);
+
+/// 温度変換トレイト
+pub trait TemperatureConverter {
+    fn to_celsius(&self) -> Celsius;
+    fn to_fahrenheit(&self) -> Fahrenheit;
+    fn to_kelvin(&self) -> Kelvin;
+}
+
+impl TemperatureConverter for Celsius {
+    fn to_celsius(&self) -> Celsius {
+        self.clone()
+    }
+
+    fn to_fahrenheit(&self) -> Fahrenheit {
+        Fahrenheit(self.0 * 9.0 / 5.0 + 32.0)
+    }
+
+    fn to_kelvin(&self) -> Kelvin {
+        Kelvin(self.0 + 273.15)
+    }
+}
+
+impl TemperatureConverter for Fahrenheit {
+    fn to_celsius(&self) -> Celsius {
+        Celsius((self.0 - 32.0) * 5.0 / 9.0)
+    }
+
+    fn to_fahrenheit(&self) -> Fahrenheit {
+        self.clone()
+    }
+
+    fn to_kelvin(&self) -> Kelvin {
+        self.to_celsius().to_kelvin()
+    }
+}
+```
+
+### 使用例
+
+```rust
+let celsius = Celsius(100.0);
+let fahrenheit = celsius.to_fahrenheit();
+assert_eq!(fahrenheit.0, 212.0);
+
+let kelvin = celsius.to_kelvin();
+assert_eq!(kelvin.0, 373.15);
+```
+
+## 3. データフォーマットアダプタ
+
+```rust
+/// レガシーユーザーデータ
+#[derive(Debug, Clone)]
+pub struct LegacyUser {
+    pub first_name: String,
+    pub last_name: String,
+    pub email_address: String,
+    pub phone_number: String,
+}
+
+/// 新しいユーザーデータ
+#[derive(Debug, Clone)]
+pub struct NewUser {
+    pub name: String,
+    pub email: String,
+    pub contacts: Vec<Contact>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Contact {
+    pub contact_type: String,
+    pub value: String,
+}
+
+/// レガシーから新形式への変換
+impl From<LegacyUser> for NewUser {
+    fn from(legacy: LegacyUser) -> NewUser {
+        NewUser {
+            name: format!("{} {}", legacy.first_name, legacy.last_name),
+            email: legacy.email_address,
+            contacts: vec![Contact {
+                contact_type: "phone".to_string(),
+                value: legacy.phone_number,
+            }],
+        }
+    }
+}
+
+/// 新形式からレガシーへの変換
+impl From<NewUser> for LegacyUser {
+    fn from(new_user: NewUser) -> LegacyUser {
+        let name_parts: Vec<&str> = new_user.name.split_whitespace().collect();
+        let phone = new_user
+            .contacts
+            .iter()
+            .find(|c| c.contact_type == "phone")
+            .map(|c| c.value.clone())
+            .unwrap_or_default();
+
+        LegacyUser {
+            first_name: name_parts.first().unwrap_or(&"").to_string(),
+            last_name: name_parts.get(1).unwrap_or(&"").to_string(),
+            email_address: new_user.email,
+            phone_number: phone,
+        }
+    }
+}
+```
+
+## 4. 外部 API アダプタ
+
+```rust
+/// 外部 API のレスポンス形式
+#[derive(Debug, Clone)]
+pub struct ExternalApiResponse {
+    pub status_code: i32,
+    pub body: String,
+    pub headers: HashMap<String, String>,
+}
+
+/// 内部形式
+#[derive(Debug, Clone)]
+pub struct InternalResponse {
+    pub success: bool,
+    pub data: String,
+    pub metadata: ResponseMetadata,
+}
+
+#[derive(Debug, Clone)]
+pub struct ResponseMetadata {
+    pub content_type: String,
+    pub timestamp: i64,
+}
+
+/// アダプタ関数
+pub fn adapt_external_response(external: ExternalApiResponse) -> InternalResponse {
+    InternalResponse {
+        success: external.status_code >= 200 && external.status_code < 300,
+        data: external.body,
+        metadata: ResponseMetadata {
+            content_type: external
+                .headers
+                .get("Content-Type")
+                .cloned()
+                .unwrap_or_else(|| "application/json".to_string()),
+            timestamp: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_secs() as i64,
+        },
+    }
+}
+```
+
+## 5. 関数アダプタ
+
+```rust
+/// 異なる引数の順序を適応
+pub fn swap_args<A, B, C, F>(f: F) -> impl Fn(B, A) -> C
+where
+    F: Fn(A, B) -> C,
+{
+    move |b, a| f(a, b)
+}
+
+/// カリー化
+pub fn curry<A, B, C, F>(f: F) -> impl Fn(A) -> Box<dyn Fn(B) -> C>
+where
+    F: Fn(A, B) -> C + Clone + 'static,
+    A: Clone + 'static,
+{
+    move |a: A| {
+        let f = f.clone();
+        let a = a.clone();
+        Box::new(move |b: B| f(a.clone(), b))
+    }
+}
+
+/// 部分適用
+pub fn partial<A, B, C, F>(f: F, a: A) -> impl Fn(B) -> C
+where
+    F: Fn(A, B) -> C,
+    A: Clone,
+{
+    move |b: B| f(a.clone(), b)
+}
+```
+
+### 使用例
+
+```rust
+let divide = |a: f64, b: f64| a / b;
+let swapped = swap_args(divide);
+
+assert_eq!(divide(10.0, 2.0), 5.0);
+assert_eq!(swapped(2.0, 10.0), 5.0);
+
+let add = |a: i32, b: i32| a + b;
+let add_5 = partial(add, 5);
+assert_eq!(add_5(3), 8);
+```
+
+## 6. イテレータアダプタ
+
+```rust
+/// カスタムイテレータアダプタ
+pub trait IteratorAdapter: Iterator {
+    /// 要素をグループ化
+    fn group_by_key<K, F>(self, key_fn: F) -> HashMap<K, Vec<Self::Item>>
+    where
+        Self: Sized,
+        K: Eq + std::hash::Hash,
+        F: Fn(&Self::Item) -> K,
+    {
+        let mut groups = HashMap::new();
+        for item in self {
+            let key = key_fn(&item);
+            groups.entry(key).or_insert_with(Vec::new).push(item);
+        }
+        groups
+    }
+
+    /// ウィンドウを作成
+    fn windowed(self, size: usize) -> Vec<Vec<Self::Item>>
+    where
+        Self: Sized,
+        Self::Item: Clone,
+    {
+        let items: Vec<_> = self.collect();
+        items.windows(size).map(|w| w.to_vec()).collect()
+    }
+}
+
+impl<I: Iterator> IteratorAdapter for I {}
+```
+
+## 7. パターンの利点
+
+1. **互換性**: 異なるインターフェース間の橋渡し
+2. **再利用**: 既存コードを新しいコンテキストで利用可能
+3. **分離**: 変換ロジックを一箇所に集約
+4. **テスト容易性**: 変換ロジックを独立してテスト可能
+
+## Rust での特徴
+
+### From/Into トレイト
+
+```rust
+impl From<LegacyUser> for NewUser {
+    fn from(legacy: LegacyUser) -> NewUser {
+        // 変換ロジック
+    }
+}
+
+// 使用
+let new_user: NewUser = legacy_user.into();
+```
+
+### 型安全な変換
+
+```rust
+// コンパイル時に型チェック
+let celsius = Celsius(100.0);
+let fahrenheit: Fahrenheit = celsius.to_fahrenheit();
+// 型が異なるので直接代入できない
+```
+
+## まとめ
+
+本章では、Adapter パターンについて学びました：
+
+1. **温度変換アダプタ**: 異なる温度単位間の変換
+2. **データフォーマットアダプタ**: レガシー形式と新形式の相互変換
+3. **外部 API アダプタ**: 外部データを内部形式に適合
+4. **関数アダプタ**: 引数の順序や数を調整
+5. **イテレータアダプタ**: イテレータに追加機能を提供
+
+Rust の From/Into トレイトと強い型システムを活用することで、型安全な変換を実現できます。
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/rust/part3/src/chapter09.rs`
+
+## 次章予告
+
+次章では、**Strategy パターン**について学びます。アルゴリズムをカプセル化して交換可能にする方法を探ります。