@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,287 @@
+# 第18章: 並行処理システム — 6言語統合ガイド
+
+## 1. はじめに
+
+並行処理は、関数型プログラミングの不変性が最も威力を発揮する領域です。共有ミュータブル状態の排除により、データ競合やデッドロックのリスクを根本的に低減できます。しかし、各言語の並行処理モデルは**根本的に異なります**。本章では、電話システムの状態機械を題材に、6 言語の並行処理アプローチを比較します。
+
+## 2. 共通の本質
+
+### 状態機械モデル
+
+すべての言語で共通する電話システムの状態遷移：
+
+```
+Idle → (dial) → Connecting → (connect) → Connected → (hangup) → Idle
+                                            ↓
+                                          (hold) → OnHold → (resume) → Connected
+```
+
+### 並行処理の課題
+
+1. **共有状態の安全な更新**: 複数スレッドからの同時アクセス
+2. **イベントの順序保証**: 状態遷移の一貫性
+3. **デッドロックの回避**: リソースの競合防止
+
+## 3. 言語別実装比較
+
+### 3.1 並行処理モデルの比較
+
+| 言語 | モデル | プリミティブ | 特徴 |
+|------|--------|-----------|------|
+| Clojure | Agent（非同期） | `agent` / `send` / `await` | 非同期メッセージ、順序保証 |
+| Scala | CAS（ロックフリー） | `AtomicReference` / `compareAndSet` | 楽観的並行制御 |
+| Elixir | Actor（OTP） | `GenServer` / `Agent` | メッセージパッシング、障害復旧 |
+| F# | Actor（MailboxProcessor） | `MailboxProcessor` / `async` | 非同期ワークフロー |
+| Haskell | STM（トランザクション） | `TVar` / `atomically` | 自動競合解決 |
+| Rust | Mutex + Async | `Arc<Mutex<T>>` / `tokio` | 所有権による安全性 |
+
+### 3.2 状態機械の実装
+
+<details>
+<summary>Clojure: Agent による非同期状態管理</summary>
+
+```clojure
+(def user-agent
+  (agent {:state :idle :peer nil}))
+
+(defmulti process-event
+  (fn [state event] [(:state state) event]))
+
+(defmethod process-event [:idle :dial] [state _]
+  (assoc state :state :connecting))
+
+(defmethod process-event [:connecting :connect] [state _]
+  (assoc state :state :connected))
+
+(defmethod process-event [:connected :hangup] [state _]
+  (assoc state :state :idle :peer nil))
+
+;; 非同期に状態更新
+(send user-agent process-event :dial)
+(await user-agent)
+```
+
+Agent は同一エージェント内の更新を**順序保証**します。複数エージェント間の調整には `ref` + STM を使います。
+
+</details>
+
+<details>
+<summary>Scala: AtomicReference + CAS</summary>
+
+```scala
+case class UserState(
+  userId: String,
+  state: PhoneState = PhoneState.Idle,
+  peer: Option[String] = None
+)
+
+class UserAgent(userId: String):
+  private val stateRef = new AtomicReference(UserState(userId))
+
+  def processEvent(event: PhoneEvent): Boolean =
+    var done = false
+    while !done do
+      val current = stateRef.get()
+      findTransition(current.state, event) match
+        case Some(Transition(_, nextState, action)) =>
+          val newState = current.copy(state = nextState)
+          if stateRef.compareAndSet(current, newState) then
+            action.foreach(_.apply())
+            done = true
+        case None =>
+          done = true
+          return false
+    true
+```
+
+CAS（Compare-And-Swap）はロックを使わず、衝突時にリトライする楽観的アプローチです。
+
+</details>
+
+<details>
+<summary>Elixir: GenServer（OTP）</summary>
+
+```elixir
+defmodule StateMachine do
+  use GenServer
+
+  def init(config) do
+    {:ok, %{state: :idle, transitions: config.transitions, log: []}}
+  end
+
+  def handle_call({:trigger, event}, _from, machine) do
+    case get_transition(machine, event) do
+      {next_state, action} ->
+        if action, do: action.()
+        updated = %{machine |
+          state: next_state,
+          log: [{machine.state, event, next_state} | machine.log]}
+        {:reply, {:ok, next_state}, updated}
+      nil ->
+        {:reply, {:error, :invalid_transition}, machine}
+    end
+  end
+end
+```
+
+GenServer は OTP のスーパービジョンツリーと統合され、プロセスがクラッシュしても**自動復旧**します。
+
+</details>
+
+<details>
+<summary>F#: MailboxProcessor</summary>
+
+```fsharp
+type AgentMessage<'TEvent> =
+    | SendEvent of 'TEvent
+    | GetState of AsyncReplyChannel<AgentState>
+
+let createAgent initialState transitions =
+    MailboxProcessor.Start(fun inbox ->
+        let rec loop state = async {
+            let! msg = inbox.Receive()
+            match msg with
+            | SendEvent event ->
+                match findTransition state.State event transitions with
+                | Some(nextState, action) ->
+                    action |> Option.iter (fun a -> a())
+                    return! loop { state with State = nextState }
+                | None ->
+                    return! loop state
+            | GetState channel ->
+                channel.Reply(state)
+                return! loop state
+        }
+        loop { State = Idle; Peer = None })
+```
+
+MailboxProcessor は F# の軽量アクターで、`async` ワークフロー内でメッセージを処理します。
+
+</details>
+
+<details>
+<summary>Haskell: STM（Software Transactional Memory）</summary>
+
+```haskell
+data UserAgentState = UserAgentState
+    { uasState :: CallState
+    , uasPeer  :: Maybe String
+    } deriving (Show)
+
+newtype UserAgent = UserAgent { uaState :: TVar UserAgentState }
+
+makeUserAgent :: STM UserAgent
+makeUserAgent = do
+    state <- newTVar (UserAgentState Idle Nothing)
+    return (UserAgent state)
+
+processEvent :: UserAgent -> Event -> STM (Maybe Action)
+processEvent ua event = do
+    current <- readTVar (uaState ua)
+    case findTransition (uasState current) event of
+        Just (nextState, action) -> do
+            writeTVar (uaState ua) current { uasState = nextState }
+            return (Just action)
+        Nothing -> return Nothing
+
+-- トランザクション内で原子的に実行
+atomically $ processEvent agent DialEvent
+```
+
+STM は**自動的に競合を検出**し、衝突した場合はトランザクションを自動リトライします。デッドロックが原理的に発生しません。
+
+</details>
+
+<details>
+<summary>Rust: Arc + Mutex + Tokio</summary>
+
+```rust
+pub struct StateMachine {
+    state: Arc<Mutex<PhoneState>>,
+    transitions: HashMap<(PhoneState, PhoneEvent), (PhoneState, Option<Action>)>,
+}
+
+impl StateMachine {
+    pub fn process_event(&self, event: PhoneEvent) -> Result<PhoneState, String> {
+        let mut state = self.state.lock().map_err(|e| e.to_string())?;
+        let key = (*state, event);
+        match self.transitions.get(&key) {
+            Some((next_state, action)) => {
+                if let Some(action) = action {
+                    action();
+                }
+                *state = *next_state;
+                Ok(*next_state)
+            }
+            None => Err("Invalid transition".to_string()),
+        }
+    }
+}
+```
+
+Rust の `Arc<Mutex<T>>` は所有権システムと組み合わさり、**コンパイル時にデータ競合を完全に排除**します。
+
+</details>
+
+### 3.3 イベントバスの実装
+
+| 言語 | 実装方式 | 購読者管理 |
+|------|---------|----------|
+| Clojure | atom + マップ | ハンドラ関数のリスト |
+| Scala | TrieMap（並行マップ） | リスナーのリスト |
+| Elixir | GenServer | PID のリスト |
+| F# | MailboxProcessor | コールバック関数のリスト |
+| Haskell | TVar + Map | ハンドラ関数のリスト |
+| Rust | Arc<Mutex<HashMap>> | Box<dyn Fn> のリスト |
+
+## 4. 比較分析
+
+### 4.1 安全性の保証レベル
+
+| 保証 | Clojure | Scala | Elixir | F# | Haskell | Rust |
+|------|---------|-------|--------|-----|---------|------|
+| データ競合防止 | ランタイム | ロックフリー | プロセス分離 | 型 + async | STM | コンパイル時 |
+| デッドロック防止 | Agent 設計 | 注意が必要 | プロセス分離 | 注意が必要 | STM で保証 | 注意が必要 |
+| 障害復旧 | なし | なし | スーパービジョン | なし | なし | なし |
+
+### 4.2 並行処理モデルのトレードオフ
+
+| モデル | 利点 | 欠点 | 代表言語 |
+|--------|------|------|---------|
+| Agent | シンプル、順序保証 | エージェント間の調整が難しい | Clojure |
+| CAS | ロックフリー、高性能 | 衝突が多いとリトライコスト | Scala |
+| Actor (OTP) | 障害復旧、スケーラビリティ | メッセージの順序管理が複雑 | Elixir |
+| MailboxProcessor | 軽量、async 統合 | .NET エコシステムに依存 | F# |
+| STM | 合成可能、デッドロック回避 | パフォーマンスオーバーヘッド | Haskell |
+| Mutex + Async | 最高の安全性（コンパイル時） | 所有権の複雑さ | Rust |
+
+### 4.3 不変性と並行処理の関係
+
+不変データ構造は並行処理の安全性に直接貢献します：
+
+- **共有しても安全**: データが変更されないため、ロック不要で共有可能
+- **スナップショット**: いつでも一貫した状態のコピーを取得可能
+- **再現性**: 同じ入力に対して常に同じ結果
+
+## 5. 実践的な選択指針
+
+| 要件 | 推奨言語 | 理由 |
+|------|---------|------|
+| 分散システム | Elixir | OTP のスーパービジョンと障害復旧 |
+| デッドロック回避 | Haskell | STM による自動的な競合解決 |
+| コンパイル時安全性 | Rust | 所有権によるデータ競合の完全排除 |
+| シンプルな並行処理 | Clojure | Agent の直感的な API |
+| 高パフォーマンス | Scala, Rust | CAS / ゼロコスト抽象化 |
+| .NET エコシステム | F# | MailboxProcessor + async |
+
+## 6. まとめ
+
+並行処理は各言語のパラダイムが最も鮮明に現れる領域です：
+
+1. **不変性が基盤**: すべての言語が不変データ構造で並行処理の安全性を確保
+2. **モデルの多様性**: Agent / Actor / STM / Mutex と根本的に異なるアプローチ
+3. **安全性のレベル**: ランタイム保証（Clojure）からコンパイル時保証（Rust）まで
+
+## 言語別個別記事
+
+- [Clojure](../clojure/18-concurrency-system.md) | [Scala](../scala/18-concurrency-system.md) | [Elixir](../elixir/18-concurrency-system.md) | [F#](../fsharp/18-concurrency-system.md) | [Haskell](../haskell/18-concurrency-system.md) | [Rust](../rust/18-concurrency-system.md)

package/lib/assets/docs/article/functional-desgin-ppp/all/19-wa-tor-simulation.md

@@ -0,0 +1,286 @@
+# 第19章: Wa-Tor シミュレーション — 6言語統合ガイド
+
+## 1. はじめに
+
+Wa-Tor は、トーラス型の 2D グリッド上で魚とサメの生態系をシミュレートするセルオートマトンです。関数型プログラミングの**不変状態管理**、**再帰的データ処理**、**多態的ディスパッチ**を大規模に実践する総合的なケーススタディです。
+
+## 2. 共通の本質
+
+### シミュレーションルール
+
+| 生物 | ルール |
+|------|--------|
+| **魚** | 隣接する空きセルに移動。一定年齢で繁殖（子を残して移動） |
+| **サメ** | 隣接する魚を捕食（エネルギー回復）。魚がいなければ空きセルに移動。エネルギー切れで死亡。一定年齢で繁殖 |
+| **水** | 空きセル。魚やサメの移動先 |
+
+### トーラス座標
+
+グリッドの端がつながったトーラス構造：
+
+```
+x' = ((x % width) + width) % width
+y' = ((y % height) + height) % height
+```
+
+### 各ステップの処理
+
+```
+1. すべてのセルを走査
+2. 各生物のルールを適用（移動・捕食・繁殖・死亡）
+3. 新しいワールド状態を生成
+```
+
+## 3. 言語別実装比較
+
+### 3.1 グリッドの表現
+
+| 言語 | グリッド型 | セル表現 | 隣接方向 |
+|------|----------|---------|---------|
+| Clojure | `Map<[x,y], Cell>` | キーワードマップ | 8 方向（Moore） |
+| Scala | `Map[Position, Cell]` | sealed trait | 8 方向 |
+| Elixir | `Map<{x,y}, Cell>` | マップ / nil（水） | 4 方向（Von Neumann） |
+| F# | `Map<Position, Cell>` | 判別共用体 | 4 方向 |
+| Haskell | `Map Location Cell` | ADT | 8 方向 |
+| Rust | `Vec<Creature>` | struct + enum | 4 方向（スパース） |
+
+<details>
+<summary>Clojure: マップベースのグリッド</summary>
+
+```clojure
+(defn make-world [width height]
+  {:type ::world :width width :height height
+   :cells {}})
+
+(defn make-fish []
+  {:type ::fish :age 0})
+
+(defn make-shark [health]
+  {:type ::shark :age 0 :health health})
+
+;; トーラス座標のラップ
+(defn wrap [{:keys [width height]} [x y]]
+  [(mod (+ x width) width)
+   (mod (+ y height) height)])
+```
+
+</details>
+
+<details>
+<summary>Scala: sealed trait + case class</summary>
+
+```scala
+sealed trait Cell
+case object Water extends Cell
+case class Fish(age: Int = 0) extends Cell
+case class Shark(age: Int = 0, health: Int) extends Cell
+
+case class World(
+  width: Int, height: Int,
+  cells: Map[Position, Cell],
+  generation: Int = 0
+)
+```
+
+</details>
+
+<details>
+<summary>Haskell: ADT + Map</summary>
+
+```haskell
+data Cell
+    = WaterCell
+    | FishCell { fishAge :: Int, fishReproductionAge :: Int }
+    | SharkCell { sharkAge :: Int, sharkReproductionAge :: Int, sharkEnergy :: Int }
+
+data World = World
+    { worldWidth  :: Int
+    , worldHeight :: Int
+    , worldCells  :: Map Location Cell
+    , worldFishReproAge :: Int
+    , worldSharkReproAge :: Int
+    , worldSharkInitialEnergy :: Int
+    }
+```
+
+</details>
+
+<details>
+<summary>Rust: スパースな生物リスト</summary>
+
+```rust
+pub enum CreatureType { Fish, Shark }
+
+pub struct Creature {
+    pub creature_type: CreatureType,
+    pub position: Position,
+    pub energy: i32,
+    pub breed_time: i32,
+}
+
+pub struct World {
+    pub width: i32,
+    pub height: i32,
+    pub creatures: Vec<Creature>,
+    pub fish_breed_time: i32,
+    pub shark_breed_time: i32,
+}
+```
+
+Rust はグリッド（`Map<Position, Cell>`）ではなく**生物リスト（`Vec<Creature>`）**を使用します。密度が低いワールドでのメモリ効率が高くなります。
+
+</details>
+
+### 3.2 状態更新のアプローチ
+
+| 言語 | 更新方法 | 乱数の扱い |
+|------|---------|----------|
+| Clojure | `assoc` / `update` で新マップ生成 | `rand-int`（暗黙的） |
+| Scala | `copy` + `Map.updated` | `Random`（暗黙的） |
+| Elixir | `Map.put` で新マップ生成 | `:rand.uniform`（暗黙的） |
+| F# | `Map.add` で新マップ生成 | `System.Random`（明示的参照） |
+| Haskell | `Map.insert` で新マップ生成 | `StdGen`（**明示的に引き回し**） |
+| Rust | `Vec` の clone + 変更 | `rand::Rng`（明示的） |
+
+<details>
+<summary>Haskell: 乱数の明示的な引き回し</summary>
+
+```haskell
+tickWorld :: World -> StdGen -> (World, StdGen)
+tickWorld world gen =
+    foldl' tickLocation (world, gen) allLocations
+  where
+    allLocations = [(x, y) | x <- [0..worldWidth world - 1]
+                           , y <- [0..worldHeight world - 1]]
+
+tickLocation :: (World, StdGen) -> Location -> (World, StdGen)
+tickLocation (world, gen) loc =
+    case Map.lookup loc (worldCells world) of
+        Just (FishCell age _) -> tickFish world loc age gen
+        Just (SharkCell age _ energy) -> tickShark world loc age energy gen
+        _ -> (world, gen)
+```
+
+Haskell は純粋関数型言語のため、乱数生成器 `StdGen` を**引数と戻り値で明示的に受け渡し**します。これにより参照透過性が保たれ、同じシードで同じ結果を再現できます。
+
+</details>
+
+### 3.3 魚のティック処理
+
+<details>
+<summary>魚の移動・繁殖ロジック比較</summary>
+
+```clojure
+;; Clojure
+(defmethod tick ::fish [world loc]
+  (let [cell (get-cell world loc)
+        neighbors (empty-neighbors world loc)
+        can-reproduce? (>= (:age cell) fish-reproduction-age)]
+    (if (seq neighbors)
+      (let [target (rand-nth neighbors)]
+        (if can-reproduce?
+          (-> world
+              (set-cell target (assoc cell :age 0))
+              (set-cell loc (make-fish)))
+          (-> world
+              (set-cell target (update cell :age inc))
+              (set-cell loc (make-water)))))
+      (update-in world [:cells loc :age] inc))))
+```
+
+```scala
+// Scala
+def tickFish(world: World, pos: Position, fish: Fish): World =
+  val emptyNeighbors = getEmptyNeighbors(world, pos)
+  if emptyNeighbors.nonEmpty then
+    val target = emptyNeighbors(Random.nextInt(emptyNeighbors.size))
+    val aged = fish.copy(age = fish.age + 1)
+    if aged.age >= world.fishBreedTime then
+      world.updated(target, Fish()).updated(pos, Fish())
+    else
+      world.updated(target, aged).updated(pos, Water)
+  else
+    world.updated(pos, fish.copy(age = fish.age + 1))
+```
+
+```haskell
+-- Haskell
+tickFish :: World -> Location -> Int -> StdGen -> (World, StdGen)
+tickFish world loc age gen =
+    let emptyNeighbors = getEmptyNeighbors world loc
+    in if null emptyNeighbors
+       then (updateCell world loc (FishCell (age + 1) reproAge), gen)
+       else let (idx, gen') = randomR (0, length emptyNeighbors - 1) gen
+                target = emptyNeighbors !! idx
+            in if age >= reproAge
+               then (reproducefish world loc target, gen')
+               else (moveFish world loc target age, gen')
+```
+
+</details>
+
+### 3.4 可視化
+
+| 言語 | 可視化方法 |
+|------|----------|
+| Clojure | Quil（Processing ラッパー）で GUI |
+| Scala | ASCII + DSL |
+| Elixir | ASCII ターミナル出力 |
+| F# | ASCII + 統計表示 |
+| Haskell | ASCII + 統計表示 |
+| Rust | ASCII ターミナル出力 |
+
+## 4. 比較分析
+
+### 4.1 設計アプローチの違い
+
+| アプローチ | 言語 | 利点 |
+|-----------|------|------|
+| グリッドベース（密） | Clojure, Scala, F#, Haskell | 隣接セルの参照が O(1) |
+| 生物リスト（疎） | Rust | メモリ効率が高い（低密度時） |
+| nil = 水 | Elixir | マップのサイズが小さい |
+| 明示的 WaterCell | Clojure, Haskell | 水セルも明示的に管理 |
+
+### 4.2 純粋性と乱数
+
+| 言語 | 乱数の純粋性 | テストの再現性 |
+|------|-----------|-------------|
+| Haskell | 完全に純粋（StdGen を引き回し） | シードで完全再現 |
+| Rust | 明示的だが副作用あり | シードで再現可能 |
+| Clojure, Scala, Elixir, F# | 暗黙的な副作用 | シード設定で再現可能 |
+
+Haskell のアプローチは最も厳密ですが、コードの複雑さが増します。他の言語は実用的なトレードオフとして暗黙的な乱数を使用しています。
+
+### 4.3 パフォーマンス特性
+
+| 言語 | メモリ管理 | 大規模ワールドでの効率 |
+|------|----------|-------------------|
+| Clojure | 永続データ構造（構造共有） | 中程度 |
+| Scala | 不変 Map + copy | 中程度 |
+| Elixir | 不変 Map | 中程度 |
+| F# | 不変 Map | 中程度 |
+| Haskell | 不変 Map + 遅延評価 | 遅延により効率化の可能性 |
+| Rust | Vec + clone | 高い（スパース表現） |
+
+## 5. 実践的な選択指針
+
+| 要件 | 推奨言語 | 理由 |
+|------|---------|------|
+| GUI 可視化 | Clojure | Quil による豊富なグラフィックス |
+| テストの完全再現性 | Haskell | 純粋な乱数管理 |
+| 大規模シミュレーション | Rust | スパース表現 + ゼロコスト抽象化 |
+| 分散シミュレーション | Elixir | プロセス分散が容易 |
+| DSL による構築 | Scala | ビルダーパターンの表現力 |
+
+## 6. まとめ
+
+Wa-Tor シミュレーションは、関数型プログラミングの総合力を試すケーススタディです：
+
+1. **不変状態管理**: 各ステップで新しいワールド状態を生成
+2. **多態的ディスパッチ**: 魚・サメ・水を統一的に処理
+3. **乱数と純粋性**: Haskell の明示的アプローチ vs 他言語の実用的トレードオフ
+4. **データ表現の選択**: グリッド vs スパースリスト
+
+## 言語別個別記事
+
+- [Clojure](../clojure/19-wa-tor-simulation.md) | [Scala](../scala/19-wa-tor-simulation.md) | [Elixir](../elixir/19-wa-tor-simulation.md) | [F#](../fsharp/19-wa-tor-simulation.md) | [Haskell](../haskell/19-wa-tor-simulation.md) | [Rust](../rust/19-wa-tor-simulation.md)