@k2works/claude-code-booster 6.2.0 → 6.3.0

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

@@ -1,95 +0,0 @@
----
-type: Article
-title: "Part I - 並行処理の基礎"
-description: "逐次処理とパスワードクラッカーの実装"
-tags: [article, grokking-concurrency, haskell, concurrency, sequential]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part I: 並行処理の基礎
-
-## 概要
-
-本章では、並行処理の基礎として逐次処理を学びます。
-
----
-
-## パスワードクラッカーの実装
-
-### SHA-256 ハッシュ計算
-
-```haskell
-{-# LANGUAGE OverloadedStrings #-}
-
-module Ch02.PasswordCracker where
-
-import Crypto.Hash.SHA256 (hash)
-import Data.ByteString.Builder (byteStringHex, toLazyByteString)
-import qualified Data.ByteString.Char8 as C8
-import qualified Data.ByteString.Lazy as BL
-
--- | Compute SHA-256 hash of a password
-getCryptoHash :: String -> String
-getCryptoHash password =
-    let hashBytes = hash (C8.pack password)
-        hexBytes = toLazyByteString (byteStringHex hashBytes)
-    in C8.unpack (BL.toStrict hexBytes)
-```
-
----
-
-### ブルートフォース探索
-
-```haskell
--- | Crack password by brute force (sequential)
-crackPassword :: String -> String -> Int -> Maybe String
-crackPassword _ _ 0 = Nothing
-crackPassword cryptoHash alphabet len =
-    crackRecursive cryptoHash alphabet "" len
-
-crackRecursive :: String -> String -> String -> Int -> Maybe String
-crackRecursive cryptoHash alphabet prefix 0 =
-    if getCryptoHash prefix == cryptoHash
-        then Just prefix
-        else Nothing
-crackRecursive cryptoHash alphabet prefix remaining =
-    foldr tryChar Nothing alphabet
-  where
-    tryChar c acc =
-        case crackRecursive cryptoHash alphabet (prefix ++ [c]) (remaining - 1) of
-            Just result -> Just result
-            Nothing -> acc
-```
-
----
-
-## 使用例
-
-```haskell
-main :: IO ()
-main = do
-    let alphabet = "ab"
-    let targetHash = getCryptoHash "ab"
-
-    case crackPassword targetHash alphabet 2 of
-        Just password -> putStrLn $ "Found: " ++ password
-        Nothing -> putStrLn "Not found"
-```
-
----
-
-## Haskell の特徴
-
-| 概念 | 説明 |
-|------|------|
-| Maybe a | 値が存在しない可能性を表現 |
-| 純粋関数 | 副作用なし、参照透過性 |
-| 遅延評価 | 必要になるまで計算しない |
-| foldr | 右畳み込みによる短絡評価 |
-
----
-
-## 次のステップ
-
-[Part II](part-2.md) では、スレッドを使った並行処理を学びます。

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

@@ -1,95 +0,0 @@
----
-type: Article
-title: "Part II - プロセスとスレッド"
-description: "forkIO と async によるスレッド操作"
-tags: [article, grokking-concurrency, haskell, concurrency, thread]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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,90 +0,0 @@
----
-type: Article
-title: "Part III - マルチタスキングとスケジューリング"
-description: "STM を使ったゲームループ"
-tags: [article, grokking-concurrency, haskell, concurrency, stm]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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,105 +0,0 @@
----
-type: Article
-title: "Part IV - タスク分解と並列パターン"
-description: "Fork/Join と Pipeline パターン"
-tags: [article, grokking-concurrency, haskell, concurrency, forkjoin, pipeline]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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 による同期を学びます。

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

@@ -1,98 +0,0 @@
----
-type: Article
-title: "Part V - 同期と排他制御"
-description: "STM によるデッドロックフリーな同期"
-tags: [article, grokking-concurrency, haskell, concurrency, stm]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part V: 同期と排他制御
-
-## 概要
-
-本章では、STM を使ったデッドロックフリーな銀行口座を学びます。
-
----
-
-## 銀行口座（STM）
-
-```haskell
-import Control.Concurrent.STM
-
--- | A thread-safe bank account using STM
-data BankAccount = BankAccount
-    { accountId      :: Int
-    , accountBalance :: TVar Int
-    }
-
--- | Create a new bank account
-newBankAccount :: Int -> Int -> IO BankAccount
-newBankAccount accId initialBalance = do
-    balance <- newTVarIO initialBalance
-    return $ BankAccount accId balance
-
--- | Get the current balance
-getBalance :: BankAccount -> IO Int
-getBalance account = readTVarIO (accountBalance account)
-
--- | Deposit money
-deposit :: BankAccount -> Int -> IO ()
-deposit account amount = atomically $
-    modifyTVar' (accountBalance account) (+ amount)
-
--- | Withdraw money
-withdraw :: BankAccount -> Int -> IO Bool
-withdraw account amount = atomically $ do
-    balance <- readTVar (accountBalance account)
-    if balance >= amount
-        then do
-            writeTVar (accountBalance account) (balance - amount)
-            return True
-        else return False
-```
-
----
-
-## アトミック送金（デッドロックフリー）
-
-```haskell
--- | Transfer money between accounts atomically
-transfer :: BankAccount -> BankAccount -> Int -> IO Bool
-transfer from to amount = atomically $ do
-    fromBalance <- readTVar (accountBalance from)
-    if fromBalance >= amount
-        then do
-            modifyTVar' (accountBalance from) (subtract amount)
-            modifyTVar' (accountBalance to) (+ amount)
-            return True
-        else return False
-```
-
----
-
-## STM の利点
-
-| 特徴 | 説明 |
-|------|------|
-| デッドロックフリー | 自動リトライによる解決 |
-| 合成可能性 | 複数の操作を組み合わせ可能 |
-| 例外安全 | ロールバックによる一貫性維持 |
-| 簡潔さ | ロック順序を考慮不要 |
-
----
-
-## STM vs MVar
-
-| 機能 | STM | MVar |
-|------|-----|------|
-| 合成 | 可能 | 困難 |
-| デッドロック | フリー | 可能性あり |
-| パフォーマンス | やや低い | 高い |
-| 複雑さ | 低い | 高い |
-
----
-
-## 次のステップ
-
-[Part VI](part-6.md) では、ノンブロッキング I/O を学びます。

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

@@ -1,94 +0,0 @@
----
-type: Article
-title: "Part VI - ノンブロッキング I/O"
-description: "async による非同期処理"
-tags: [article, grokking-concurrency, haskell, concurrency, async]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part VI: ノンブロッキング I/O
-
-## 概要
-
-本章では、Haskell の async ライブラリを使用した非同期処理を学びます。
-
----
-
-## ブロッキング vs ノンブロッキング
-
-### ブロッキング I/O
-
-```haskell
--- スレッドは I/O 完了まで待機
-content <- readFile "file.txt"
-```
-
-### ノンブロッキング I/O (async)
-
-```haskell
-import Control.Concurrent.Async
-
--- バックグラウンドで実行
-handle <- async $ readFile "file.txt"
--- 他の処理を実行
-doSomethingElse
--- 結果を取得
-content <- wait handle
-```
-
----
-
-## async の基本
-
-```haskell
-import Control.Concurrent.Async
-
-fetchData :: String -> IO String
-fetchData url = do
-    threadDelay 1000000  -- 1秒待機
-    return $ "Data from " ++ url
-
-main :: IO ()
-main = do
-    -- 非同期実行
-    handle <- async $ fetchData "https://example.com"
-
-    -- 同期的に待機
-    result <- wait handle
-    putStrLn result
-```
-
----
-
-## 並行実行
-
-```haskell
-import Control.Concurrent.Async
-
-downloadAll :: [String] -> IO [String]
-downloadAll urls = mapConcurrently fetchData urls
-
--- 使用例
-main :: IO ()
-main = do
-    results <- downloadAll
-        ["https://a.com", "https://b.com", "https://c.com"]
-    mapM_ putStrLn results
-```
-
----
-
-## メリット
-
-| 項目 | ブロッキング | async |
-|------|-------------|-------|
-| スレッド消費 | 待機中も占有 | 効率的 |
-| スケーラビリティ | 低い | 高い |
-| コード複雑さ | 低い | やや高い |
-
----
-
-## 次のステップ
-
-[Part VII](part-7.md) では、async ライブラリの詳細を学びます。

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

@@ -1,110 +0,0 @@
----
-type: Article
-title: "Part VII - 非同期プログラミング"
-description: "async ライブラリの詳細"
-tags: [article, grokking-concurrency, haskell, concurrency, async]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# Part VII: 非同期プログラミング
-
-## 概要
-
-本章では、Haskell の async ライブラリを詳しく学びます。
-
----
-
-## Async 型
-
-```haskell
--- Async a は非同期計算を表す
-data Async a
-
--- 非同期計算を開始
-async :: IO a -> IO (Async a)
-
--- 結果を待機
-wait :: Async a -> IO a
-
--- キャンセル
-cancel :: Async a -> IO ()
-```
-
----
-
-## 並行実行
-
-```haskell
-import Control.Concurrent.Async
-
--- 順次実行
-sequential :: IO (Int, Int)
-sequential = do
-    a <- computeA
-    b <- computeB
-    return (a, b)
-
--- 並行実行
-parallel :: IO (Int, Int)
-parallel = concurrently computeA computeB
-```
-
----
-
-## race
-
-```haskell
-import Control.Concurrent.Async
-
--- 先に終わった方を返す
-raceExample :: IO (Either String Int)
-raceExample = race fetchFromServerA fetchFromServerB
-```
-
----
-
-## エラーハンドリング
-
-```haskell
-import Control.Concurrent.Async
-import Control.Exception (try, SomeException)
-
-safeComputation :: IO (Either SomeException Int)
-safeComputation = do
-    result <- async riskyComputation
-    try (wait result)
-```
-
----
-
-## withAsync（リソース安全）
-
-```haskell
-import Control.Concurrent.Async
-
--- 完了後に自動的にキャンセル
-withAsync action $ \handle -> do
-    result <- wait handle
-    processResult result
-```
-
----
-
-## async 関数一覧
-
-| 関数 | 説明 |
-|------|------|
-| async | バックグラウンド実行 |
-| wait | 完了待機 |
-| cancel | キャンセル |
-| race | 競争 |
-| concurrently | 両方並行実行 |
-| mapConcurrently | 並列 map |
-| withAsync | リソース安全な実行 |
-
----
-
-## 次のステップ
-
-[Part VIII](part-8.md) では、MapReduce パターンを学びます。