@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,96 @@
+---
+title: Part I - 並行処理の基礎
+description: 逐次処理とパスワードクラッカーの実装
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, sequential, haskell
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# 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

@@ -0,0 +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) では、マルチタスキングとゲームループを学びます。

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

@@ -0,0 +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 パターンを学びます。

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

@@ -0,0 +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 による同期を学びます。

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

@@ -0,0 +1,99 @@
+---
+title: Part V - 同期と排他制御
+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 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

@@ -0,0 +1,95 @@
+---
+title: Part VI - ノンブロッキング I/O
+description: async による非同期処理
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, async, haskell
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# 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

@@ -0,0 +1,111 @@
+---
+title: Part VII - 非同期プログラミング
+description: async ライブラリの詳細
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, async, haskell
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# 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 パターンを学びます。