@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/rust/18-concurrency-system.md

@@ -0,0 +1,315 @@
+# 第18章: 並行処理システム
+
+## はじめに
+
+本章では、Rust の並行処理機能を使って、状態機械、イベントバス、タスクキューなどを実装します。Rust の所有権システムと Arc/Mutex を活用した安全な並行プログラミングを学びます。
+
+## 1. 状態機械（電話の例）
+
+```rust
+use std::sync::{Arc, Mutex};
+
+/// 電話の状態
+#[derive(Debug, Clone, PartialEq)]
+pub enum PhoneState {
+    Idle,
+    Ringing,
+    Connected,
+    OnHold,
+}
+
+/// 電話イベント
+#[derive(Debug, Clone)]
+pub enum PhoneEvent {
+    IncomingCall { caller: String },
+    Answer,
+    HangUp,
+    Hold,
+    Resume,
+}
+
+/// 電話
+#[derive(Debug, Clone)]
+pub struct Phone {
+    pub state: PhoneState,
+    pub caller: Option<String>,
+}
+
+impl Phone {
+    pub fn new() -> Phone {
+        Phone {
+            state: PhoneState::Idle,
+            caller: None,
+        }
+    }
+
+    pub fn handle_event(&self, event: PhoneEvent) -> Result<Phone, String> {
+        match (&self.state, event) {
+            (PhoneState::Idle, PhoneEvent::IncomingCall { caller }) => {
+                Ok(Phone {
+                    state: PhoneState::Ringing,
+                    caller: Some(caller),
+                })
+            }
+            (PhoneState::Ringing, PhoneEvent::Answer) => {
+                Ok(Phone {
+                    state: PhoneState::Connected,
+                    caller: self.caller.clone(),
+                })
+            }
+            (PhoneState::Ringing, PhoneEvent::HangUp) => {
+                Ok(Phone::new())
+            }
+            (PhoneState::Connected, PhoneEvent::Hold) => {
+                Ok(Phone {
+                    state: PhoneState::OnHold,
+                    caller: self.caller.clone(),
+                })
+            }
+            (PhoneState::Connected, PhoneEvent::HangUp) => {
+                Ok(Phone::new())
+            }
+            (PhoneState::OnHold, PhoneEvent::Resume) => {
+                Ok(Phone {
+                    state: PhoneState::Connected,
+                    caller: self.caller.clone(),
+                })
+            }
+            (PhoneState::OnHold, PhoneEvent::HangUp) => {
+                Ok(Phone::new())
+            }
+            (state, event) => {
+                Err(format!("Invalid event {:?} in state {:?}", event, state))
+            }
+        }
+    }
+}
+```
+
+## 2. イベントバス
+
+```rust
+use std::collections::HashMap;
+
+/// イベントハンドラー型
+pub type EventHandler = Box<dyn Fn(&str) + Send + Sync>;
+
+/// イベントバス
+pub struct EventBus {
+    handlers: Arc<Mutex<HashMap<String, Vec<EventHandler>>>>,
+}
+
+impl EventBus {
+    pub fn new() -> EventBus {
+        EventBus {
+            handlers: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    pub fn subscribe(&self, event_type: &str, handler: EventHandler) {
+        let mut handlers = self.handlers.lock().unwrap();
+        handlers
+            .entry(event_type.to_string())
+            .or_insert_with(Vec::new)
+            .push(handler);
+    }
+
+    pub fn publish(&self, event_type: &str, data: &str) {
+        let handlers = self.handlers.lock().unwrap();
+        if let Some(event_handlers) = handlers.get(event_type) {
+            for handler in event_handlers {
+                handler(data);
+            }
+        }
+    }
+}
+```
+
+## 3. 非同期タスクキュー
+
+```rust
+use tokio::sync::mpsc;
+use tokio::task::JoinHandle;
+
+/// タスク
+pub type Task = Box<dyn FnOnce() + Send + 'static>;
+
+/// タスクキュー
+pub struct TaskQueue {
+    sender: mpsc::Sender<Task>,
+    #[allow(dead_code)]
+    handles: Vec<JoinHandle<()>>,
+}
+
+impl TaskQueue {
+    pub fn new(num_workers: usize) -> TaskQueue {
+        let (sender, receiver) = mpsc::channel::<Task>(100);
+        let receiver = Arc::new(Mutex::new(receiver));
+        let mut handles = Vec::new();
+
+        for _ in 0..num_workers {
+            let receiver = Arc::clone(&receiver);
+            let handle = tokio::spawn(async move {
+                loop {
+                    let task = {
+                        let mut rx = receiver.lock().unwrap();
+                        rx.try_recv().ok()
+                    };
+                    
+                    if let Some(task) = task {
+                        task();
+                    } else {
+                        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+                    }
+                }
+            });
+            handles.push(handle);
+        }
+
+        TaskQueue { sender, handles }
+    }
+
+    pub async fn submit(&self, task: Task) -> Result<(), String> {
+        self.sender
+            .send(task)
+            .await
+            .map_err(|e| e.to_string())
+    }
+}
+```
+
+## 4. アトミックカウンター
+
+```rust
+use std::sync::atomic::{AtomicI64, Ordering};
+
+/// スレッドセーフなカウンター
+pub struct AtomicCounter {
+    value: AtomicI64,
+}
+
+impl AtomicCounter {
+    pub fn new(initial: i64) -> AtomicCounter {
+        AtomicCounter {
+            value: AtomicI64::new(initial),
+        }
+    }
+
+    pub fn increment(&self) -> i64 {
+        self.value.fetch_add(1, Ordering::SeqCst) + 1
+    }
+
+    pub fn decrement(&self) -> i64 {
+        self.value.fetch_sub(1, Ordering::SeqCst) - 1
+    }
+
+    pub fn get(&self) -> i64 {
+        self.value.load(Ordering::SeqCst)
+    }
+
+    pub fn add(&self, delta: i64) -> i64 {
+        self.value.fetch_add(delta, Ordering::SeqCst) + delta
+    }
+}
+```
+
+## 5. アクション処理システム
+
+```rust
+/// アクションの種類
+#[derive(Debug, Clone)]
+pub enum Action {
+    Start,
+    Stop,
+    Process { data: String },
+    Shutdown,
+}
+
+/// アクションハンドラー
+pub trait ActionHandler: Send + Sync {
+    fn handle(&self, action: &Action) -> Result<String, String>;
+}
+
+/// ロギングハンドラー
+pub struct LoggingHandler {
+    logs: Arc<Mutex<Vec<String>>>,
+}
+
+impl ActionHandler for LoggingHandler {
+    fn handle(&self, action: &Action) -> Result<String, String> {
+        let log = format!("Handled action: {:?}", action);
+        self.logs.lock().unwrap().push(log.clone());
+        Ok(log)
+    }
+}
+
+/// アクションディスパッチャー
+pub struct ActionDispatcher {
+    handlers: Vec<Arc<dyn ActionHandler>>,
+}
+
+impl ActionDispatcher {
+    pub fn new() -> ActionDispatcher {
+        ActionDispatcher {
+            handlers: Vec::new(),
+        }
+    }
+
+    pub fn register(&mut self, handler: Arc<dyn ActionHandler>) {
+        self.handlers.push(handler);
+    }
+
+    pub fn dispatch(&self, action: &Action) -> Vec<Result<String, String>> {
+        self.handlers
+            .iter()
+            .map(|h| h.handle(action))
+            .collect()
+    }
+}
+```
+
+## 6. パターンの適用
+
+1. **状態機械**: ADT による状態とイベントの表現
+2. **イベントバス**: Observer パターンの並行版
+3. **タスクキュー**: Command パターンの非同期版
+4. **Arc/Mutex**: スレッドセーフな共有状態
+
+## 7. Rust での特徴
+
+### 所有権による安全性
+
+```rust
+// Arc で所有権を共有、Mutex で排他制御
+let handlers: Arc<Mutex<HashMap<String, Vec<EventHandler>>>> = 
+    Arc::new(Mutex::new(HashMap::new()));
+```
+
+### Send/Sync トレイト
+
+```rust
+// Send: 他のスレッドに送信可能
+// Sync: 複数スレッドから参照可能
+pub trait ActionHandler: Send + Sync {
+    fn handle(&self, action: &Action) -> Result<String, String>;
+}
+```
+
+## まとめ
+
+本章では、並行処理システムを通じて：
+
+1. 状態機械による並行状態管理
+2. イベントバスによる非同期メッセージング
+3. タスクキューによる並行処理
+4. Arc/Mutex による安全な共有状態
+
+を学びました。Rust の所有権システムにより、データ競合を防ぎながら並行プログラミングが可能です。
+
+## 参考コード
+
+- ソースコード: `apps/rust/part6/src/chapter18.rs`
+
+## 次章予告
+
+次章では、**Wa-Tor シミュレーション**を通じて、セルラーオートマトンを関数型で実装します。

package/lib/assets/docs/article/functional-desgin-ppp/rust/19-wator-simulation.md

@@ -0,0 +1,311 @@
+# 第19章: Wa-Tor シミュレーション
+
+## はじめに
+
+本章では、Wa-Tor（Water Torus）シミュレーションを実装します。これは魚とサメの捕食-被食関係をシミュレートするセルラーオートマトンです。関数型のアプローチで、不変データ構造と純粋関数を使って実装します。
+
+## 1. データ構造
+
+```rust
+/// 座標
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Position {
+    pub x: i32,
+    pub y: i32,
+}
+
+impl Position {
+    pub fn new(x: i32, y: i32) -> Position {
+        Position { x, y }
+    }
+
+    pub fn wrap(&self, width: i32, height: i32) -> Position {
+        Position {
+            x: ((self.x % width) + width) % width,
+            y: ((self.y % height) + height) % height,
+        }
+    }
+}
+
+/// 生物の種類
+#[derive(Debug, Clone, PartialEq)]
+pub enum CreatureType {
+    Fish,
+    Shark,
+}
+
+/// 生物
+#[derive(Debug, Clone)]
+pub struct Creature {
+    pub creature_type: CreatureType,
+    pub position: Position,
+    pub energy: i32,           // サメのエネルギー
+    pub breed_time: i32,       // 繁殖までの時間
+}
+
+impl Creature {
+    pub fn fish(position: Position, breed_time: i32) -> Creature {
+        Creature {
+            creature_type: CreatureType::Fish,
+            position,
+            energy: 0,
+            breed_time,
+        }
+    }
+
+    pub fn shark(position: Position, energy: i32, breed_time: i32) -> Creature {
+        Creature {
+            creature_type: CreatureType::Shark,
+            position,
+            energy,
+            breed_time,
+        }
+    }
+}
+
+/// ワールド
+#[derive(Debug, Clone)]
+pub struct World {
+    pub width: i32,
+    pub height: i32,
+    pub creatures: Vec<Creature>,
+    pub fish_breed_time: i32,
+    pub shark_breed_time: i32,
+    pub shark_energy_gain: i32,
+    pub shark_initial_energy: i32,
+}
+```
+
+## 2. 移動ロジック
+
+```rust
+impl World {
+    /// 隣接セルを取得
+    pub fn neighbors(&self, pos: Position) -> Vec<Position> {
+        let directions = vec![
+            Position::new(0, -1),  // 上
+            Position::new(0, 1),   // 下
+            Position::new(-1, 0),  // 左
+            Position::new(1, 0),   // 右
+        ];
+
+        directions
+            .into_iter()
+            .map(|d| Position::new(pos.x + d.x, pos.y + d.y).wrap(self.width, self.height))
+            .collect()
+    }
+
+    /// 空のセルを探す
+    pub fn find_empty_neighbors(&self, pos: Position) -> Vec<Position> {
+        self.neighbors(pos)
+            .into_iter()
+            .filter(|p| !self.creatures.iter().any(|c| c.position == *p))
+            .collect()
+    }
+
+    /// 魚がいるセルを探す
+    pub fn find_fish_neighbors(&self, pos: Position) -> Vec<Position> {
+        self.neighbors(pos)
+            .into_iter()
+            .filter(|p| {
+                self.creatures
+                    .iter()
+                    .any(|c| c.position == *p && c.creature_type == CreatureType::Fish)
+            })
+            .collect()
+    }
+}
+```
+
+## 3. シミュレーションステップ
+
+```rust
+impl World {
+    /// 魚を移動
+    fn move_fish(&self, fish: &Creature, rng: &mut impl Rng) -> (Option<Creature>, Option<Creature>) {
+        let empty = self.find_empty_neighbors(fish.position);
+
+        if empty.is_empty() {
+            // 移動できない
+            let new_fish = Creature {
+                breed_time: fish.breed_time - 1,
+                ..fish.clone()
+            };
+            (Some(new_fish), None)
+        } else {
+            // ランダムに移動
+            let new_pos = empty[rng.gen_range(0..empty.len())];
+
+            if fish.breed_time <= 1 {
+                // 繁殖
+                let parent = Creature::fish(new_pos, self.fish_breed_time);
+                let child = Creature::fish(fish.position, self.fish_breed_time);
+                (Some(parent), Some(child))
+            } else {
+                let new_fish = Creature {
+                    position: new_pos,
+                    breed_time: fish.breed_time - 1,
+                    ..fish.clone()
+                };
+                (Some(new_fish), None)
+            }
+        }
+    }
+
+    /// サメを移動
+    fn move_shark(&self, shark: &Creature, rng: &mut impl Rng) -> (Option<Creature>, Option<Creature>, Option<Position>) {
+        let fish_neighbors = self.find_fish_neighbors(shark.position);
+        let empty_neighbors = self.find_empty_neighbors(shark.position);
+
+        // エネルギーがなくなったら死亡
+        if shark.energy <= 0 {
+            return (None, None, None);
+        }
+
+        if !fish_neighbors.is_empty() {
+            // 魚を食べる
+            let target = fish_neighbors[rng.gen_range(0..fish_neighbors.len())];
+            let new_energy = shark.energy + self.shark_energy_gain;
+
+            if shark.breed_time <= 1 {
+                // 繁殖
+                let parent = Creature::shark(target, new_energy - 1, self.shark_breed_time);
+                let child = Creature::shark(shark.position, self.shark_initial_energy, self.shark_breed_time);
+                (Some(parent), Some(child), Some(target))
+            } else {
+                let new_shark = Creature {
+                    position: target,
+                    energy: new_energy - 1,
+                    breed_time: shark.breed_time - 1,
+                    ..shark.clone()
+                };
+                (Some(new_shark), None, Some(target))
+            }
+        } else if !empty_neighbors.is_empty() {
+            // 空のセルに移動
+            let new_pos = empty_neighbors[rng.gen_range(0..empty_neighbors.len())];
+
+            if shark.breed_time <= 1 {
+                let parent = Creature::shark(new_pos, shark.energy - 1, self.shark_breed_time);
+                let child = Creature::shark(shark.position, self.shark_initial_energy, self.shark_breed_time);
+                (Some(parent), Some(child), None)
+            } else {
+                let new_shark = Creature {
+                    position: new_pos,
+                    energy: shark.energy - 1,
+                    breed_time: shark.breed_time - 1,
+                    ..shark.clone()
+                };
+                (Some(new_shark), None, None)
+            }
+        } else {
+            // 移動できない
+            let new_shark = Creature {
+                energy: shark.energy - 1,
+                breed_time: shark.breed_time - 1,
+                ..shark.clone()
+            };
+            (Some(new_shark), None, None)
+        }
+    }
+
+    /// 1ステップ実行
+    pub fn step(&self, rng: &mut impl Rng) -> World {
+        // 実装省略（全生物を順番に処理）
+        self.clone()
+    }
+}
+```
+
+## 4. シミュレーション実行
+
+```rust
+/// シミュレーション結果
+#[derive(Debug, Clone)]
+pub struct SimulationStats {
+    pub step: usize,
+    pub fish_count: usize,
+    pub shark_count: usize,
+}
+
+/// シミュレーションを実行
+pub fn run_simulation(
+    initial_world: World,
+    steps: usize,
+    mut rng: impl Rng,
+) -> Vec<SimulationStats> {
+    let mut world = initial_world;
+    let mut stats = Vec::new();
+
+    for step in 0..steps {
+        let fish_count = world.creatures
+            .iter()
+            .filter(|c| c.creature_type == CreatureType::Fish)
+            .count();
+        let shark_count = world.creatures
+            .iter()
+            .filter(|c| c.creature_type == CreatureType::Shark)
+            .count();
+
+        stats.push(SimulationStats {
+            step,
+            fish_count,
+            shark_count,
+        });
+
+        world = world.step(&mut rng);
+    }
+
+    stats
+}
+```
+
+## 5. 可視化
+
+```rust
+impl World {
+    /// ASCII アートで表示
+    pub fn to_ascii(&self) -> String {
+        let mut grid = vec![vec!['.'; self.width as usize]; self.height as usize];
+
+        for creature in &self.creatures {
+            let ch = match creature.creature_type {
+                CreatureType::Fish => 'f',
+                CreatureType::Shark => 'S',
+            };
+            grid[creature.position.y as usize][creature.position.x as usize] = ch;
+        }
+
+        grid.into_iter()
+            .map(|row| row.into_iter().collect::<String>())
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+}
+```
+
+## 6. パターンの適用
+
+1. **不変データ**: World, Creature は不変
+2. **純粋関数**: step() は新しい World を返す
+3. **ADT**: CreatureType による生物種別
+4. **イテレータ**: 効率的な集計処理
+
+## まとめ
+
+本章では、Wa-Tor シミュレーションを通じて：
+
+1. 不変データ構造によるシミュレーション状態管理
+2. 純粋関数による状態遷移
+3. ADT による生物種別の表現
+4. イテレータによる効率的なデータ処理
+
+を学びました。関数型のアプローチにより、再現性があり、テストしやすいシミュレーションが実現できます。
+
+## 参考コード
+
+- ソースコード: `apps/rust/part6/src/chapter19.rs`
+
+## 次章予告
+
+次章では、**パターン間の相互作用**について学びます。複数のパターンを組み合わせた設計を探ります。