@k2works/claude-code-booster 6.1.0 → 6.3.0

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

@@ -1,296 +0,0 @@
----
-type: Article
-title: "第18章: 並行処理システム — 6言語統合ガイド"
-description: "並行処理は、関数型プログラミングの不変性が最も威力を発揮する領域です。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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

@@ -1,295 +0,0 @@
----
-type: Article
-title: "第19章: Wa-Tor シミュレーション — 6言語統合ガイド"
-description: "Wa-Tor は、トーラス型の 2D グリッド上で魚とサメの生態系をシミュレートするセルオートマトンです。"
-tags: [article, functional-desgin-ppp, all]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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-wator-simulation.md) | [Scala](../scala/19-wator-simulation.md) | [Elixir](../elixir/19-wator-simulation.md) | [F#](../fsharp/19-wator-simulation.md) | [Haskell](../haskell/19-wator-simulation.md) | [Rust](../rust/19-wator-simulation.md)