@k2works/claude-code-booster 4.6.0 → 4.7.0

package/lib/assets/docs/article/grokking-concurrency/haskell/part-2.md

@@ -1,96 +1,96 @@
----
-title: Part II - プロセスとスレッド
-description: forkIO と async によるスレッド操作
-published: true
-date: 2025-12-31T10:00:00.000Z
-tags: concurrency, thread, haskell
-editor: markdown
-dateCreated: 2025-12-31T10:00:00.000Z
----
-
-# Part II: プロセスとスレッド
-
-## 概要
-
-本章では、Haskell の forkIO と async ライブラリを使ったスレッド操作を学びます。
-
----
-
-## スレッドの基本
-
-### forkIO によるスレッド作成
-
-```haskell
-import Control.Concurrent (forkIO, ThreadId)
-
--- | Create and start a new thread
-createThread :: IO () -> IO ThreadId
-createThread = forkIO
-```
-
----
-
-### async による複数スレッドの実行
-
-```haskell
-import Control.Concurrent.Async (async, wait)
-import Control.Monad (forM, forM_)
-
--- | Run multiple threads and wait for completion
-runThreads :: Int -> (Int -> IO ()) -> IO ()
-runThreads count action = do
-    handles <- forM [0..count-1] $ \i -> async (action i)
-    forM_ handles wait
-```
-
----
-
-## 並列パスワードクラッカー
-
-```haskell
-import Control.Concurrent.Async (mapConcurrently)
-import Data.Maybe (listToMaybe, catMaybes)
-
--- | Crack password using parallel execution
-crackPasswordParallel :: String -> String -> Int -> IO (Maybe String)
-crackPasswordParallel _ _ 0 = return Nothing
-crackPasswordParallel cryptoHash alphabet len = do
-    -- Parallelize on first character
-    results <- mapConcurrently (tryFirstChar cryptoHash alphabet len) alphabet
-    return $ listToMaybe (catMaybes results)
-```
-
----
-
-## async ライブラリ
-
-| 関数 | 説明 |
-|------|------|
-| async | バックグラウンドで実行 |
-| wait | 完了を待機 |
-| cancel | キャンセル |
-| mapConcurrently | 並列 map |
-
----
-
-## 使用例
-
-```haskell
-import Control.Concurrent.STM
-
-main :: IO ()
-main = do
-    counter <- newTVarIO (0 :: Int)
-
-    runThreads 5 $ \_ ->
-        atomically $ modifyTVar' counter (+1)
-
-    result <- readTVarIO counter
-    print result  -- 5
-```
-
----
-
-## 次のステップ
-
-[Part III](part-3.md) では、マルチタスキングとゲームループを学びます。
+---
+title: Part II - プロセスとスレッド
+description: forkIO と async によるスレッド操作
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, thread, haskell
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part II: プロセスとスレッド
+
+## 概要
+
+本章では、Haskell の forkIO と async ライブラリを使ったスレッド操作を学びます。
+
+---
+
+## スレッドの基本
+
+### forkIO によるスレッド作成
+
+```haskell
+import Control.Concurrent (forkIO, ThreadId)
+
+-- | Create and start a new thread
+createThread :: IO () -> IO ThreadId
+createThread = forkIO
+```
+
+---
+
+### async による複数スレッドの実行
+
+```haskell
+import Control.Concurrent.Async (async, wait)
+import Control.Monad (forM, forM_)
+
+-- | Run multiple threads and wait for completion
+runThreads :: Int -> (Int -> IO ()) -> IO ()
+runThreads count action = do
+    handles <- forM [0..count-1] $ \i -> async (action i)
+    forM_ handles wait
+```
+
+---
+
+## 並列パスワードクラッカー
+
+```haskell
+import Control.Concurrent.Async (mapConcurrently)
+import Data.Maybe (listToMaybe, catMaybes)
+
+-- | Crack password using parallel execution
+crackPasswordParallel :: String -> String -> Int -> IO (Maybe String)
+crackPasswordParallel _ _ 0 = return Nothing
+crackPasswordParallel cryptoHash alphabet len = do
+    -- Parallelize on first character
+    results <- mapConcurrently (tryFirstChar cryptoHash alphabet len) alphabet
+    return $ listToMaybe (catMaybes results)
+```
+
+---
+
+## async ライブラリ
+
+| 関数 | 説明 |
+|------|------|
+| async | バックグラウンドで実行 |
+| wait | 完了を待機 |
+| cancel | キャンセル |
+| mapConcurrently | 並列 map |
+
+---
+
+## 使用例
+
+```haskell
+import Control.Concurrent.STM
+
+main :: IO ()
+main = do
+    counter <- newTVarIO (0 :: Int)
+
+    runThreads 5 $ \_ ->
+        atomically $ modifyTVar' counter (+1)
+
+    result <- readTVarIO counter
+    print result  -- 5
+```
+
+---
+
+## 次のステップ
+
+[Part III](part-3.md) では、マルチタスキングとゲームループを学びます。

package/lib/assets/docs/article/grokking-concurrency/haskell/part-3.md

@@ -1,91 +1,91 @@
----
-title: Part III - マルチタスキングとスケジューリング
-description: STM を使ったゲームループ
-published: true
-date: 2025-12-31T10:00:00.000Z
-tags: concurrency, stm, haskell
-editor: markdown
-dateCreated: 2025-12-31T10:00:00.000Z
----
-
-# Part III: マルチタスキングとスケジューリング
-
-## 概要
-
-本章では、STM を使ったゲームループを学びます。
-
----
-
-## ゲームタスク
-
-```haskell
--- | A game task that can be processed
-data GameTask = GameTask
-    { taskName   :: String
-    , taskAction :: IO ()
-    }
-```
-
----
-
-## プロセッサフリーイベント（STM）
-
-```haskell
-import Control.Concurrent.STM
-
--- | Event for signaling processor availability
-newtype ProcessorFreeEvent = ProcessorFreeEvent (TVar Bool)
-
--- | Create a new processor free event
-newProcessorFreeEvent :: IO ProcessorFreeEvent
-newProcessorFreeEvent = ProcessorFreeEvent <$> newTVarIO False
-
--- | Wait for the event to be signaled
-waitEvent :: ProcessorFreeEvent -> IO ()
-waitEvent (ProcessorFreeEvent var) = atomically $ do
-    ready <- readTVar var
-    if ready
-        then writeTVar var False
-        else retry
-
--- | Signal the event
-signalEvent :: ProcessorFreeEvent -> IO ()
-signalEvent (ProcessorFreeEvent var) = atomically $ writeTVar var True
-```
-
----
-
-## ゲームループ
-
-```haskell
-import Control.Monad (forM_, replicateM_)
-
--- | Simple game loop that processes tasks
-gameLoop :: [GameTask] -> Int -> IO ()
-gameLoop tasks iterations =
-    replicateM_ iterations $ forM_ tasks taskAction
-
--- | Cooperative game loop with event signaling
-cooperativeGameLoop :: [GameTask] -> ProcessorFreeEvent -> Int -> IO ()
-cooperativeGameLoop tasks event iterations =
-    replicateM_ iterations $ forM_ tasks $ \task -> do
-        taskAction task
-        signalEvent event
-```
-
----
-
-## STM の特徴
-
-| 関数 | 説明 |
-|------|------|
-| atomically | トランザクションを実行 |
-| readTVar | TVar を読み取る |
-| writeTVar | TVar に書き込む |
-| retry | 条件が満たされるまで待機 |
-
----
-
-## 次のステップ
-
-[Part IV](part-4.md) では、Fork/Join と Pipeline パターンを学びます。
+---
+title: Part III - マルチタスキングとスケジューリング
+description: STM を使ったゲームループ
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, stm, haskell
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part III: マルチタスキングとスケジューリング
+
+## 概要
+
+本章では、STM を使ったゲームループを学びます。
+
+---
+
+## ゲームタスク
+
+```haskell
+-- | A game task that can be processed
+data GameTask = GameTask
+    { taskName   :: String
+    , taskAction :: IO ()
+    }
+```
+
+---
+
+## プロセッサフリーイベント（STM）
+
+```haskell
+import Control.Concurrent.STM
+
+-- | Event for signaling processor availability
+newtype ProcessorFreeEvent = ProcessorFreeEvent (TVar Bool)
+
+-- | Create a new processor free event
+newProcessorFreeEvent :: IO ProcessorFreeEvent
+newProcessorFreeEvent = ProcessorFreeEvent <$> newTVarIO False
+
+-- | Wait for the event to be signaled
+waitEvent :: ProcessorFreeEvent -> IO ()
+waitEvent (ProcessorFreeEvent var) = atomically $ do
+    ready <- readTVar var
+    if ready
+        then writeTVar var False
+        else retry
+
+-- | Signal the event
+signalEvent :: ProcessorFreeEvent -> IO ()
+signalEvent (ProcessorFreeEvent var) = atomically $ writeTVar var True
+```
+
+---
+
+## ゲームループ
+
+```haskell
+import Control.Monad (forM_, replicateM_)
+
+-- | Simple game loop that processes tasks
+gameLoop :: [GameTask] -> Int -> IO ()
+gameLoop tasks iterations =
+    replicateM_ iterations $ forM_ tasks taskAction
+
+-- | Cooperative game loop with event signaling
+cooperativeGameLoop :: [GameTask] -> ProcessorFreeEvent -> Int -> IO ()
+cooperativeGameLoop tasks event iterations =
+    replicateM_ iterations $ forM_ tasks $ \task -> do
+        taskAction task
+        signalEvent event
+```
+
+---
+
+## STM の特徴
+
+| 関数 | 説明 |
+|------|------|
+| atomically | トランザクションを実行 |
+| readTVar | TVar を読み取る |
+| writeTVar | TVar に書き込む |
+| retry | 条件が満たされるまで待機 |
+
+---
+
+## 次のステップ
+
+[Part IV](part-4.md) では、Fork/Join と Pipeline パターンを学びます。

package/lib/assets/docs/article/grokking-concurrency/haskell/part-4.md

@@ -1,106 +1,106 @@
----
-title: Part IV - タスク分解と並列パターン
-description: Fork/Join と Pipeline パターン
-published: true
-date: 2025-12-31T10:00:00.000Z
-tags: concurrency, forkjoin, pipeline, haskell
-editor: markdown
-dateCreated: 2025-12-31T10:00:00.000Z
----
-
-# Part IV: タスク分解と並列パターン
-
-## 概要
-
-本章では、Fork/Join と Pipeline パターンを学びます。
-
----
-
-## Fork/Join パターン
-
-### 投票カウンター
-
-```haskell
-import Control.Concurrent.Async (mapConcurrently)
-import Data.Map.Strict (Map)
-import qualified Data.Map.Strict as Map
-
--- | Count votes sequentially
-countVotes :: [String] -> Map String Int
-countVotes = foldl' countOne Map.empty
-  where
-    countOne acc vote = Map.insertWith (+) vote 1 acc
-
--- | Count votes using Fork/Join pattern
-countVotesParallel :: [String] -> IO (Map String Int)
-countVotesParallel [] = return Map.empty
-countVotesParallel votes = do
-    let chunks = splitIntoChunks 4 votes
-    results <- mapConcurrently (return . countVotes) chunks
-    return $ foldl' (Map.unionWith (+)) Map.empty results
-```
-
----
-
-## Pipeline パターン
-
-### Pipeline 構造
-
-```haskell
--- | A pipeline of processing stages
-newtype Pipeline a = Pipeline [a -> a]
-
--- | Create a new empty pipeline
-newPipeline :: Pipeline a
-newPipeline = Pipeline []
-
--- | Add a stage to the pipeline
-addStage :: (a -> a) -> Pipeline a -> Pipeline a
-addStage f (Pipeline stages) = Pipeline (stages ++ [f])
-
--- | Run the pipeline on a single input
-runPipeline :: Pipeline a -> a -> a
-runPipeline (Pipeline stages) input = foldl (flip ($)) input stages
-```
-
----
-
-### TQueue による並行パイプライン
-
-```haskell
-import Control.Concurrent.STM
-
--- | Concurrent pipeline using TQueues
-concurrentPipeline :: [a -> a] -> [a] -> IO [a]
-concurrentPipeline processors inputs = do
-    -- Create queues between stages
-    queues <- forM [1..numQueues] $ \_ -> newTQueueIO
-    -- Feed input, create processor threads, collect results
-    ...
-```
-
----
-
-## 使用例
-
-```haskell
-main :: IO ()
-main = do
-    -- Pipeline
-    let pipeline = addStage (\x -> x - 3)
-                 $ addStage (*2)
-                 $ addStage (+1)
-                 $ newPipeline
-    print $ runPipeline pipeline (5 :: Int)  -- 9
-
-    -- Fork/Join
-    let votes = ["A", "B", "A", "A", "B", "C"]
-    result <- countVotesParallel votes
-    print result  -- fromList [("A",3),("B",2),("C",1)]
-```
-
----
-
-## 次のステップ
-
-[Part V](part-5.md) では、STM による同期を学びます。
+---
+title: Part IV - タスク分解と並列パターン
+description: Fork/Join と Pipeline パターン
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, forkjoin, pipeline, haskell
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part IV: タスク分解と並列パターン
+
+## 概要
+
+本章では、Fork/Join と Pipeline パターンを学びます。
+
+---
+
+## Fork/Join パターン
+
+### 投票カウンター
+
+```haskell
+import Control.Concurrent.Async (mapConcurrently)
+import Data.Map.Strict (Map)
+import qualified Data.Map.Strict as Map
+
+-- | Count votes sequentially
+countVotes :: [String] -> Map String Int
+countVotes = foldl' countOne Map.empty
+  where
+    countOne acc vote = Map.insertWith (+) vote 1 acc
+
+-- | Count votes using Fork/Join pattern
+countVotesParallel :: [String] -> IO (Map String Int)
+countVotesParallel [] = return Map.empty
+countVotesParallel votes = do
+    let chunks = splitIntoChunks 4 votes
+    results <- mapConcurrently (return . countVotes) chunks
+    return $ foldl' (Map.unionWith (+)) Map.empty results
+```
+
+---
+
+## Pipeline パターン
+
+### Pipeline 構造
+
+```haskell
+-- | A pipeline of processing stages
+newtype Pipeline a = Pipeline [a -> a]
+
+-- | Create a new empty pipeline
+newPipeline :: Pipeline a
+newPipeline = Pipeline []
+
+-- | Add a stage to the pipeline
+addStage :: (a -> a) -> Pipeline a -> Pipeline a
+addStage f (Pipeline stages) = Pipeline (stages ++ [f])
+
+-- | Run the pipeline on a single input
+runPipeline :: Pipeline a -> a -> a
+runPipeline (Pipeline stages) input = foldl (flip ($)) input stages
+```
+
+---
+
+### TQueue による並行パイプライン
+
+```haskell
+import Control.Concurrent.STM
+
+-- | Concurrent pipeline using TQueues
+concurrentPipeline :: [a -> a] -> [a] -> IO [a]
+concurrentPipeline processors inputs = do
+    -- Create queues between stages
+    queues <- forM [1..numQueues] $ \_ -> newTQueueIO
+    -- Feed input, create processor threads, collect results
+    ...
+```
+
+---
+
+## 使用例
+
+```haskell
+main :: IO ()
+main = do
+    -- Pipeline
+    let pipeline = addStage (\x -> x - 3)
+                 $ addStage (*2)
+                 $ addStage (+1)
+                 $ newPipeline
+    print $ runPipeline pipeline (5 :: Int)  -- 9
+
+    -- Fork/Join
+    let votes = ["A", "B", "A", "A", "B", "C"]
+    result <- countVotesParallel votes
+    print result  -- fromList [("A",3),("B",2),("C",1)]
+```
+
+---
+
+## 次のステップ
+
+[Part V](part-5.md) では、STM による同期を学びます。