@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/rust/20-pattern-interactions.md

@@ -0,0 +1,304 @@
+# 第20章: パターン間の相互作用
+
+## はじめに
+
+本章では、これまで学んだデザインパターンを組み合わせて、より複雑なシステムを構築する方法を学びます。パターンの組み合わせにより、柔軟で拡張性の高いアーキテクチャを実現します。
+
+## 1. Composite + Decorator
+
+図形に装飾を追加しながら、階層構造を維持します。
+
+```rust
+/// 図形トレイト
+pub trait Shape: CloneShape {
+    fn draw(&self) -> String;
+    fn area(&self) -> f64;
+    fn translate(&self, dx: f64, dy: f64) -> Box<dyn Shape>;
+    fn scale(&self, factor: f64) -> Box<dyn Shape>;
+}
+
+/// 円
+#[derive(Clone)]
+pub struct Circle {
+    pub x: f64,
+    pub y: f64,
+    pub radius: f64,
+}
+
+impl Shape for Circle {
+    fn draw(&self) -> String {
+        format!("Circle at ({}, {}) with radius {}", self.x, self.y, self.radius)
+    }
+
+    fn area(&self) -> f64 {
+        std::f64::consts::PI * self.radius * self.radius
+    }
+    // ...
+}
+
+/// 色付きデコレータ
+pub struct ColoredShape {
+    pub shape: Box<dyn Shape>,
+    pub color: String,
+}
+
+impl Shape for ColoredShape {
+    fn draw(&self) -> String {
+        format!("[Color: {}] {}", self.color, self.shape.draw())
+    }
+
+    fn area(&self) -> f64 {
+        self.shape.area()
+    }
+    // ...
+}
+
+/// 境界線デコレータ
+pub struct BorderedShape {
+    pub shape: Box<dyn Shape>,
+    pub border_width: f64,
+}
+
+impl Shape for BorderedShape {
+    fn draw(&self) -> String {
+        format!("[Border: {}px] {}", self.border_width, self.shape.draw())
+    }
+    // ...
+}
+
+/// 複合図形（Composite）
+pub struct CompositeShape {
+    pub shapes: Vec<Box<dyn Shape>>,
+}
+
+impl Shape for CompositeShape {
+    fn draw(&self) -> String {
+        let drawings: Vec<String> = self.shapes.iter().map(|s| s.draw()).collect();
+        format!("Composite [{}]", drawings.join(", "))
+    }
+
+    fn area(&self) -> f64 {
+        self.shapes.iter().map(|s| s.area()).sum()
+    }
+    // ...
+}
+```
+
+### 使用例
+
+```rust
+// 色付きの円
+let colored_circle = ColoredShape {
+    shape: Box::new(Circle { x: 0.0, y: 0.0, radius: 5.0 }),
+    color: "red".to_string(),
+};
+
+// 境界線付きの四角形
+let bordered_rect = BorderedShape {
+    shape: Box::new(Rectangle { x: 10.0, y: 10.0, width: 20.0, height: 15.0 }),
+    border_width: 2.0,
+};
+
+// 複合図形
+let composite = CompositeShape {
+    shapes: vec![
+        Box::new(colored_circle),
+        Box::new(bordered_rect),
+    ],
+};
+```
+
+## 2. Command + Observer
+
+コマンドの実行を監視し、履歴を管理します。
+
+```rust
+/// コマンドトレイト
+pub trait Command: CloneCommand {
+    fn execute(&self, canvas: &Canvas) -> Canvas;
+    fn undo(&self, canvas: &Canvas) -> Canvas;
+}
+
+/// キャンバスイベント
+#[derive(Debug, Clone)]
+pub enum CanvasEvent {
+    CommandExecuted { command_name: String },
+    CommandUndone { command_name: String },
+    CommandRedone { command_name: String },
+}
+
+/// オブザーバートレイト
+pub trait CanvasObserver {
+    fn on_event(&mut self, event: &CanvasEvent);
+}
+
+/// Observable キャンバス
+pub struct ObservableCanvas {
+    pub canvas: Canvas,
+    pub observers: Vec<Box<dyn CanvasObserver>>,
+    pub history: Vec<Box<dyn Command>>,
+    pub history_index: usize,
+}
+
+impl ObservableCanvas {
+    pub fn execute(&mut self, command: Box<dyn Command>) {
+        self.canvas = command.execute(&self.canvas);
+        
+        // 履歴を更新
+        self.history.truncate(self.history_index);
+        self.history.push(command.clone_box());
+        self.history_index += 1;
+
+        // オブザーバーに通知
+        let event = CanvasEvent::CommandExecuted {
+            command_name: "Command".to_string(),
+        };
+        self.notify(&event);
+    }
+
+    pub fn undo(&mut self) -> bool {
+        if self.history_index > 0 {
+            self.history_index -= 1;
+            let command = &self.history[self.history_index];
+            self.canvas = command.undo(&self.canvas);
+
+            let event = CanvasEvent::CommandUndone {
+                command_name: "Command".to_string(),
+            };
+            self.notify(&event);
+            true
+        } else {
+            false
+        }
+    }
+
+    fn notify(&mut self, event: &CanvasEvent) {
+        for observer in &mut self.observers {
+            observer.on_event(event);
+        }
+    }
+}
+```
+
+## 3. Strategy + Factory
+
+ファクトリが戦略に基づいてオブジェクトを生成します。
+
+```rust
+/// レンダリング戦略
+pub trait RenderStrategy {
+    fn render(&self, shape: &dyn Shape) -> String;
+}
+
+pub struct TextRenderer;
+pub struct JsonRenderer;
+pub struct SvgRenderer;
+
+impl RenderStrategy for TextRenderer {
+    fn render(&self, shape: &dyn Shape) -> String {
+        shape.draw()
+    }
+}
+
+impl RenderStrategy for JsonRenderer {
+    fn render(&self, shape: &dyn Shape) -> String {
+        format!(r#"{{"type":"shape","area":{}}}"#, shape.area())
+    }
+}
+
+/// 図形ファクトリトレイト
+pub trait ShapeFactory {
+    fn create_circle(&self, x: f64, y: f64, radius: f64) -> Box<dyn Shape>;
+    fn create_rectangle(&self, x: f64, y: f64, width: f64, height: f64) -> Box<dyn Shape>;
+}
+
+/// 標準ファクトリ
+pub struct SimpleShapeFactory;
+
+impl ShapeFactory for SimpleShapeFactory {
+    fn create_circle(&self, x: f64, y: f64, radius: f64) -> Box<dyn Shape> {
+        Box::new(Circle { x, y, radius })
+    }
+    // ...
+}
+
+/// 色付きファクトリ
+pub struct ColoredShapeFactory {
+    pub color: String,
+}
+
+impl ShapeFactory for ColoredShapeFactory {
+    fn create_circle(&self, x: f64, y: f64, radius: f64) -> Box<dyn Shape> {
+        Box::new(ColoredShape {
+            shape: Box::new(Circle { x, y, radius }),
+            color: self.color.clone(),
+        })
+    }
+    // ...
+}
+```
+
+## 4. DSL による宣言的な構築
+
+```rust
+/// 図形ビルダー DSL
+pub mod dsl {
+    use super::*;
+
+    pub fn circle(x: f64, y: f64, radius: f64) -> Box<dyn Shape> {
+        Box::new(Circle { x, y, radius })
+    }
+
+    pub fn rectangle(x: f64, y: f64, width: f64, height: f64) -> Box<dyn Shape> {
+        Box::new(Rectangle { x, y, width, height })
+    }
+
+    pub fn colored(shape: Box<dyn Shape>, color: &str) -> Box<dyn Shape> {
+        Box::new(ColoredShape {
+            shape,
+            color: color.to_string(),
+        })
+    }
+
+    pub fn bordered(shape: Box<dyn Shape>, width: f64) -> Box<dyn Shape> {
+        Box::new(BorderedShape {
+            shape,
+            border_width: width,
+        })
+    }
+
+    pub fn composite(shapes: Vec<Box<dyn Shape>>) -> Box<dyn Shape> {
+        Box::new(CompositeShape { shapes })
+    }
+}
+
+// 使用例
+let scene = composite(vec![
+    colored(circle(0.0, 0.0, 10.0), "red"),
+    bordered(rectangle(20.0, 20.0, 30.0, 20.0), 2.0),
+]);
+```
+
+## 5. パターンの組み合わせの利点
+
+1. **柔軟性**: 各パターンの利点を組み合わせ
+2. **拡張性**: 新しい機能を追加しやすい
+3. **テスト容易性**: 各コンポーネントを独立してテスト
+4. **分離**: 関心事の分離が明確
+
+## まとめ
+
+本章では、パターン間の相互作用について学びました：
+
+1. **Composite + Decorator**: 階層構造と装飾の組み合わせ
+2. **Command + Observer**: 操作の監視と履歴管理
+3. **Strategy + Factory**: 戦略に基づくオブジェクト生成
+4. **DSL**: 宣言的な構築
+
+## 参考コード
+
+- ソースコード: `apps/rust/part7/src/chapter20.rs`
+
+## 次章予告
+
+次章では、**ベストプラクティス**について学びます。関数型デザインの実践的なガイドラインを探ります。

package/lib/assets/docs/article/functional-desgin-ppp/rust/21-best-practices.md

@@ -0,0 +1,336 @@
+# 第21章: ベストプラクティス
+
+## はじめに
+
+本章では、Rust における関数型デザインのベストプラクティスをまとめます。データ中心設計、純粋関数、テスト可能な設計など、実践的なガイドラインを紹介します。
+
+## 1. データ中心設計
+
+### シンプルなデータ構造
+
+```rust
+use rust_decimal::Decimal;
+
+/// ユーザー（シンプルなデータ構造）
+#[derive(Debug, Clone, PartialEq)]
+pub struct User {
+    pub id: String,
+    pub name: String,
+    pub email: String,
+    pub created_at: i64,
+}
+
+/// 注文アイテム
+#[derive(Debug, Clone, PartialEq)]
+pub struct OrderItem {
+    pub product_id: String,
+    pub quantity: i32,
+    pub price: Decimal,
+}
+
+/// 注文
+#[derive(Debug, Clone, PartialEq)]
+pub struct Order {
+    pub id: String,
+    pub user_id: String,
+    pub items: Vec<OrderItem>,
+    pub status: OrderStatus,
+}
+
+#[derive(Debug, Clone, PartialEq, Default)]
+pub enum OrderStatus {
+    #[default]
+    Pending,
+    Processing,
+    Completed,
+    Cancelled,
+}
+```
+
+## 2. 小さな純粋関数
+
+```rust
+pub mod order_calculations {
+    use super::*;
+
+    /// アイテムの合計を計算
+    pub fn calculate_item_total(item: &OrderItem) -> Decimal {
+        item.price * Decimal::from(item.quantity)
+    }
+
+    /// 注文の合計を計算
+    pub fn calculate_order_total(order: &Order) -> Decimal {
+        order.items.iter().map(calculate_item_total).sum()
+    }
+
+    /// 割引を適用
+    pub fn apply_discount(total: Decimal, discount_rate: Decimal) -> Decimal {
+        total * (Decimal::ONE - discount_rate)
+    }
+
+    /// 税金を適用
+    pub fn apply_tax(total: Decimal, tax_rate: Decimal) -> Decimal {
+        total * (Decimal::ONE + tax_rate)
+    }
+}
+```
+
+## 3. データ検証
+
+```rust
+/// 検証結果
+pub enum ValidationResult<T> {
+    Valid(T),
+    Invalid(Vec<String>),
+}
+
+impl<T> ValidationResult<T> {
+    pub fn is_valid(&self) -> bool {
+        matches!(self, ValidationResult::Valid(_))
+    }
+
+    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> ValidationResult<U> {
+        match self {
+            ValidationResult::Valid(v) => ValidationResult::Valid(f(v)),
+            ValidationResult::Invalid(errs) => ValidationResult::Invalid(errs),
+        }
+    }
+}
+
+pub mod validation {
+    use super::*;
+    use regex::Regex;
+
+    pub fn valid_email(email: &str) -> bool {
+        let re = Regex::new(r"^[^@]+@[^@]+\.[^@]+$").unwrap();
+        re.is_match(email)
+    }
+
+    pub fn validate_user(user: User) -> ValidationResult<User> {
+        let mut errors = Vec::new();
+
+        if user.name.trim().is_empty() {
+            errors.push("Name is required".to_string());
+        }
+        if !valid_email(&user.email) {
+            errors.push("Invalid email format".to_string());
+        }
+
+        if errors.is_empty() {
+            ValidationResult::Valid(user)
+        } else {
+            ValidationResult::Invalid(errors)
+        }
+    }
+}
+```
+
+## 4. イミュータブルな更新
+
+```rust
+pub mod immutable_updates {
+    use super::*;
+
+    pub fn update_user_email(user: User, new_email: &str) -> Result<User, String> {
+        if validation::valid_email(new_email) {
+            Ok(User {
+                email: new_email.to_string(),
+                ..user
+            })
+        } else {
+            Err("Invalid email format".to_string())
+        }
+    }
+
+    pub fn cancel_order(order: Order) -> Result<Order, String> {
+        if order.status == OrderStatus::Pending {
+            Ok(Order {
+                status: OrderStatus::Cancelled,
+                ..order
+            })
+        } else {
+            Err("Only pending orders can be cancelled".to_string())
+        }
+    }
+}
+```
+
+## 5. 高階関数によるデコレーション
+
+```rust
+pub mod function_decorators {
+    use std::collections::HashMap;
+    use std::sync::{Arc, Mutex};
+    use std::time::Instant;
+
+    /// ロギングデコレータ
+    pub fn with_logging<A: Clone + std::fmt::Debug, B: std::fmt::Debug>(
+        f: impl Fn(A) -> B,
+        mut logger: impl FnMut(String),
+    ) -> impl FnMut(A) -> B {
+        move |a: A| {
+            logger(format!("Input: {:?}", a));
+            let result = f(a);
+            logger(format!("Output: {:?}", result));
+            result
+        }
+    }
+
+    /// キャッシュデコレータ
+    pub fn with_cache<A: Clone + Eq + std::hash::Hash + 'static, B: Clone + 'static>(
+        f: impl Fn(A) -> B + 'static,
+    ) -> impl FnMut(A) -> B {
+        let cache: Arc<Mutex<HashMap<A, B>>> = Arc::new(Mutex::new(HashMap::new()));
+        move |a: A| {
+            let mut cache = cache.lock().unwrap();
+            if let Some(v) = cache.get(&a) {
+                v.clone()
+            } else {
+                let result = f(a.clone());
+                cache.insert(a, result.clone());
+                result
+            }
+        }
+    }
+}
+```
+
+## 6. 依存性注入
+
+```rust
+/// リポジトリトレイト
+pub trait Repository<T: Clone, ID> {
+    fn find_by_id(&self, id: &ID) -> Option<T>;
+    fn find_all(&self) -> Vec<T>;
+    fn save(&mut self, entity: T) -> T;
+    fn delete(&mut self, id: &ID) -> bool;
+}
+
+/// 時間プロバイダー
+pub trait Clock {
+    fn now(&self) -> i64;
+}
+
+/// ID生成器
+pub trait IdGenerator {
+    fn generate(&mut self) -> String;
+}
+
+/// テスト用の実装
+pub struct FixedClock {
+    time: i64,
+}
+
+impl Clock for FixedClock {
+    fn now(&self) -> i64 {
+        self.time
+    }
+}
+
+pub struct SequentialIdGenerator {
+    prefix: String,
+    counter: usize,
+}
+
+impl IdGenerator for SequentialIdGenerator {
+    fn generate(&mut self) -> String {
+        self.counter += 1;
+        format!("{}-{}", self.prefix, self.counter)
+    }
+}
+```
+
+## 7. サービス層
+
+```rust
+/// ユーザーサービス
+pub struct UserService<R, C, I>
+where
+    R: Repository<User, String>,
+    C: Clock,
+    I: IdGenerator,
+{
+    repository: R,
+    clock: C,
+    id_generator: I,
+}
+
+impl<R, C, I> UserService<R, C, I>
+where
+    R: Repository<User, String>,
+    C: Clock,
+    I: IdGenerator,
+{
+    pub fn new(repository: R, clock: C, id_generator: I) -> Self {
+        Self { repository, clock, id_generator }
+    }
+
+    pub fn create_user(&mut self, name: &str, email: &str) -> Result<User, Vec<String>> {
+        let user = User {
+            id: self.id_generator.generate(),
+            name: name.to_string(),
+            email: email.to_string(),
+            created_at: self.clock.now(),
+        };
+
+        match validation::validate_user(user) {
+            ValidationResult::Valid(u) => Ok(self.repository.save(u)),
+            ValidationResult::Invalid(errors) => Err(errors),
+        }
+    }
+}
+```
+
+## 8. 結果型
+
+```rust
+/// カスタム Result 型
+#[derive(Debug, Clone)]
+pub enum Result2<E, A> {
+    Success(A),
+    Failure(E),
+}
+
+impl<E, A> Result2<E, A> {
+    pub fn map<B, F: FnOnce(A) -> B>(self, f: F) -> Result2<E, B> {
+        match self {
+            Result2::Success(a) => Result2::Success(f(a)),
+            Result2::Failure(e) => Result2::Failure(e),
+        }
+    }
+
+    pub fn flat_map<B, F: FnOnce(A) -> Result2<E, B>>(self, f: F) -> Result2<E, B> {
+        match self {
+            Result2::Success(a) => f(a),
+            Result2::Failure(e) => Result2::Failure(e),
+        }
+    }
+}
+```
+
+## 9. ベストプラクティスまとめ
+
+1. **データ中心**: ビジネスロジックをデータ構造で表現
+2. **純粋関数**: 副作用を分離し、テスト容易性を向上
+3. **不変データ**: 状態変更は新しいデータを作成
+4. **型で表現**: enum で状態、トレイトで振る舞いを表現
+5. **依存性注入**: テスト可能な設計
+6. **小さな関数**: 単一責任、合成可能
+
+## まとめ
+
+本章では、Rust における関数型デザインのベストプラクティスを学びました：
+
+1. データ中心設計
+2. 純粋関数による計算
+3. 検証と不変更新
+4. 高階関数によるデコレーション
+5. 依存性注入によるテスト可能性
+
+## 参考コード
+
+- ソースコード: `apps/rust/part7/src/chapter21.rs`
+
+## 次章予告
+
+次章では、**OO から FP への移行**について学びます。既存のオブジェクト指向コードを関数型に移行する方法を探ります。