@k2works/claude-code-booster 6.2.0 → 6.3.0

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

@@ -1,324 +0,0 @@
----
-type: Article
-title: "第18章: 並行処理システム"
-description: "本章では、Rust の並行処理機能を使って、状態機械、イベントバス、タスクキューなどを実装します。"
-tags: [article, functional-desgin-ppp, rust]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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

@@ -1,320 +0,0 @@
----
-type: Article
-title: "第19章: Wa-Tor シミュレーション"
-description: "本章では、Wa-Tor（Water Torus）シミュレーションを実装します。"
-tags: [article, functional-desgin-ppp, rust]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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`
-
-## 次章予告
-
-次章では、**パターン間の相互作用**について学びます。複数のパターンを組み合わせた設計を探ります。