@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,363 @@
+# 第18章 並行処理システム - 状態機械パターン
+
+## 概要
+
+この章では、Software Transactional Memory (STM) を使用した並行処理システムを実装します。電話呼び出しの状態機械をモデル化し、複数のユーザーエージェントが安全に状態を管理できるシステムを構築します。
+
+## 学習目標
+
+- STM による安全な並行状態管理
+- 状態機械パターンの関数型実装
+- トランザクション的な状態遷移
+- 純粋関数と副作用の分離
+
+## 状態機械の基礎
+
+### 状態の定義
+
+```haskell
+-- | 通話状態
+data CallState
+  = Idle                    -- 待機中
+  | Calling                 -- 発信中
+  | Dialing                 -- ダイヤル中
+  | WaitingForConnection    -- 接続待ち
+  | Talking                 -- 通話中
+  deriving (Show, Eq, Ord)
+```
+
+### イベントの定義
+
+```haskell
+-- | 状態遷移を引き起こすイベント
+data Event
+  = Call        -- 発信
+  | Ring        -- 着信
+  | Dialtone    -- ダイヤルトーン
+  | Ringback    -- 呼び出し音
+  | Connected   -- 接続完了
+  | Disconnect  -- 切断
+  deriving (Show, Eq, Ord)
+```
+
+### アクションの定義
+
+```haskell
+-- | 遷移時に実行するアクション
+data Action
+  = CallerOffHook   -- 発信者が受話器を取る
+  | CalleeOffHook   -- 着信者が受話器を取る
+  | Dial            -- ダイヤル
+  | Talk            -- 通話開始
+  | NoAction        -- アクションなし
+  deriving (Show, Eq)
+```
+
+## 状態機械の実装
+
+### 遷移の定義
+
+```haskell
+-- | 状態遷移
+data Transition = Transition
+  { transNextState :: CallState  -- 次の状態
+  , transAction :: Action        -- 実行するアクション
+  } deriving (Show, Eq)
+
+-- | 状態機械: (状態, イベント) → 遷移
+type StateMachine = Map (CallState, Event) Transition
+```
+
+### 電話状態機械
+
+```haskell
+phoneStateMachine :: StateMachine
+phoneStateMachine = Map.fromList
+  [ ((Idle, Call), Transition Calling CallerOffHook)
+  , ((Idle, Ring), Transition WaitingForConnection CalleeOffHook)
+  , ((Idle, Disconnect), Transition Idle NoAction)
+  , ((Calling, Dialtone), Transition Dialing Dial)
+  , ((Dialing, Ringback), Transition WaitingForConnection NoAction)
+  , ((WaitingForConnection, Connected), Transition Talking Talk)
+  , ((Talking, Disconnect), Transition Idle NoAction)
+  ]
+```
+
+### 純粋な遷移関数
+
+```haskell
+-- | 遷移の取得
+getTransition :: StateMachine -> CallState -> Event -> Maybe Transition
+getTransition sm state event = Map.lookup (state, event) sm
+
+-- | 純粋な状態遷移
+transition :: StateMachine -> CallState -> Event -> Maybe CallState
+transition sm state event = transNextState <$> getTransition sm state event
+```
+
+## STM によるユーザーエージェント
+
+### ユーザーエージェントの状態
+
+```haskell
+-- | ユーザーエージェントの内部状態
+data UserAgentState = UserAgentState
+  { uasUserId :: String       -- ユーザーID
+  , uasState :: CallState     -- 現在の通話状態
+  , uasPeer :: Maybe String   -- 通話相手
+  } deriving (Show, Eq)
+
+-- | STM ベースのユーザーエージェント
+data UserAgent = UserAgent
+  { uaState :: TVar UserAgentState  -- STM変数
+  , uaMachine :: StateMachine       -- 状態機械
+  }
+```
+
+### エージェントの作成
+
+```haskell
+-- | 新しいユーザーエージェントを作成
+makeUserAgent :: String -> STM UserAgent
+makeUserAgent userId = do
+  state <- newTVar UserAgentState
+    { uasUserId = userId
+    , uasState = Idle
+    , uasPeer = Nothing
+    }
+  return UserAgent
+    { uaState = state
+    , uaMachine = phoneStateMachine
+    }
+```
+
+### 状態の読み取り
+
+```haskell
+-- | 現在の状態を取得
+getUserState :: UserAgent -> STM CallState
+getUserState ua = uasState <$> readTVar (uaState ua)
+
+-- | ユーザーIDを取得
+getUserId :: UserAgent -> STM String
+getUserId ua = uasUserId <$> readTVar (uaState ua)
+
+-- | 通話相手を取得
+getPeer :: UserAgent -> STM (Maybe String)
+getPeer ua = uasPeer <$> readTVar (uaState ua)
+```
+
+## 状態遷移の処理
+
+### トランザクション的な遷移
+
+```haskell
+-- | 遷移を処理してアクションを返す
+processTransition :: UserAgent -> Event -> Maybe String -> STM (Maybe Action)
+processTransition ua event peer = do
+  currentState <- readTVar (uaState ua)
+  case getTransition (uaMachine ua) (uasState currentState) event of
+    Nothing -> return Nothing
+    Just trans -> do
+      writeTVar (uaState ua) currentState
+        { uasState = transNextState trans
+        , uasPeer = peer <|> uasPeer currentState
+        }
+      return (Just (transAction trans))
+
+-- | イベントを送信
+sendEvent :: UserAgent -> Event -> STM (Maybe Action)
+sendEvent ua event = processTransition ua event Nothing
+
+-- | 相手情報付きでイベントを送信
+sendEventWithPeer :: UserAgent -> Event -> String -> STM (Maybe Action)
+sendEventWithPeer ua event peer = processTransition ua event (Just peer)
+```
+
+## 使用例
+
+### 発信者のフロー
+
+```haskell
+-- 発信者のフローをシミュレート
+callerFlow :: IO ()
+callerFlow = atomically $ do
+  alice <- makeUserAgent "alice"
+  
+  -- 発信
+  _ <- sendEventWithPeer alice Call "bob"
+  s1 <- getUserState alice  -- Calling
+  
+  -- ダイヤルトーン受信
+  _ <- sendEvent alice Dialtone
+  s2 <- getUserState alice  -- Dialing
+  
+  -- 呼び出し音受信
+  _ <- sendEvent alice Ringback
+  s3 <- getUserState alice  -- WaitingForConnection
+  
+  -- 接続完了
+  _ <- sendEvent alice Connected
+  s4 <- getUserState alice  -- Talking
+  
+  -- 切断
+  _ <- sendEvent alice Disconnect
+  s5 <- getUserState alice  -- Idle
+  
+  return ()
+```
+
+### 着信者のフロー
+
+```haskell
+-- 着信者のフローをシミュレート
+calleeFlow :: IO ()
+calleeFlow = atomically $ do
+  bob <- makeUserAgent "bob"
+  
+  -- 着信
+  _ <- sendEventWithPeer bob Ring "alice"
+  s1 <- getUserState bob  -- WaitingForConnection
+  
+  -- 接続完了
+  _ <- sendEvent bob Connected
+  s2 <- getUserState bob  -- Talking
+  
+  -- 切断
+  _ <- sendEvent bob Disconnect
+  s3 <- getUserState bob  -- Idle
+  
+  return ()
+```
+
+### 複数エージェントの独立動作
+
+```haskell
+-- 複数のエージェントが独立して動作
+multipleAgents :: IO ()
+multipleAgents = do
+  (aliceState, bobState) <- atomically $ do
+    alice <- makeUserAgent "alice"
+    bob <- makeUserAgent "bob"
+    
+    -- それぞれ独立して状態遷移
+    _ <- sendEvent alice Call
+    _ <- sendEvent bob Ring
+    
+    as <- getUserState alice
+    bs <- getUserState bob
+    return (as, bs)
+  
+  print aliceState  -- Calling
+  print bobState    -- WaitingForConnection
+```
+
+## アクションの実行
+
+```haskell
+-- | アクションの説明を生成
+executeAction :: Action -> String -> Maybe String -> String
+executeAction action userId peer = case action of
+  CallerOffHook -> userId ++ " picked up the phone to call " ++ peerStr
+  CalleeOffHook -> userId ++ " answered the phone from " ++ peerStr
+  Dial -> userId ++ " is dialing " ++ peerStr
+  Talk -> userId ++ " is talking to " ++ peerStr
+  NoAction -> ""
+  where
+    peerStr = maybe "unknown" id peer
+```
+
+## STM の利点
+
+### 1. 原子性
+
+```haskell
+-- 複数の状態更新が原子的に実行される
+atomicUpdate :: IO ()
+atomicUpdate = atomically $ do
+  ua <- makeUserAgent "test"
+  -- この2つの操作は一緒に成功または失敗
+  _ <- sendEvent ua Call
+  _ <- sendEvent ua Dialtone
+  return ()
+```
+
+### 2. 競合の自動解決
+
+STM は競合を検出し、トランザクションを自動的に再試行します。
+
+### 3. デッドロックの回避
+
+ロックベースの並行処理と異なり、STM はデッドロックを回避します。
+
+### 4. 合成可能性
+
+```haskell
+-- 複数のSTM操作を合成できる
+composedTransaction :: STM ()
+composedTransaction = do
+  alice <- makeUserAgent "alice"
+  bob <- makeUserAgent "bob"
+  _ <- sendEvent alice Call
+  _ <- sendEvent bob Ring
+  return ()
+```
+
+## テスト
+
+```haskell
+spec :: Spec
+spec = do
+  describe "Pure State Machine" $ do
+    it "transitions from Idle to Calling on Call event" $ do
+      transition phoneStateMachine Idle Call `shouldBe` Just Calling
+
+    it "returns Nothing for invalid transitions" $ do
+      transition phoneStateMachine Idle Dialtone `shouldBe` Nothing
+
+  describe "UserAgent (STM)" $ do
+    it "creates agent in Idle state" $ do
+      state <- atomically $ do
+        ua <- makeUserAgent "alice"
+        getUserState ua
+      state `shouldBe` Idle
+
+    it "transitions through full caller flow" $ do
+      states <- atomically $ do
+        ua <- makeUserAgent "alice"
+        _ <- sendEvent ua Call
+        s1 <- getUserState ua
+        _ <- sendEvent ua Dialtone
+        s2 <- getUserState ua
+        _ <- sendEvent ua Ringback
+        s3 <- getUserState ua
+        _ <- sendEvent ua Connected
+        s4 <- getUserState ua
+        return [s1, s2, s3, s4]
+      states `shouldBe` [Calling, Dialing, WaitingForConnection, Talking]
+```
+
+## 設計のポイント
+
+### 純粋関数と副作用の分離
+
+- 状態機械の定義は純粋なデータ
+- 遷移関数は純粋（`transition`）
+- STM操作のみが副作用を持つ
+
+### 型安全性
+
+- 代数的データ型で状態とイベントを表現
+- 不正な状態遷移は型レベルで防止
+
+### 合成可能性
+
+- 小さなSTM操作を組み合わせて大きな操作を構築
+- トランザクションの境界を柔軟に設定
+
+## まとめ
+
+- 状態機械は関数型プログラミングで自然に表現できる
+- STM は安全な並行状態管理を提供する
+- 純粋関数と副作用を分離することで、テストと推論が容易になる
+- 代数的データ型により、状態空間を明確に定義できる