@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,104 @@
+---
+title: Part V - 同期と排他制御
+description: 銀行口座で学ぶロックとデッドロック回避
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, synchronization, lock, fsharp
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part V: 同期と排他制御
+
+## 概要
+
+本章では、銀行口座を例に同期とデッドロック回避を学びます。
+
+---
+
+## 銀行口座レコード
+
+```fsharp
+type BankAccount = {
+    Lock: obj
+    mutable Balance: int
+}
+
+module BankAccount =
+    /// Create a new bank account
+    let createAccount (initialBalance: int) : BankAccount =
+        { Lock = obj(); Balance = initialBalance }
+
+    /// Get the current balance
+    let getBalance (account: BankAccount) : int =
+        lock account.Lock (fun () -> account.Balance)
+
+    /// Deposit money into the account
+    let deposit (account: BankAccount) (amount: int) : unit =
+        lock account.Lock (fun () ->
+            account.Balance <- account.Balance + amount
+        )
+
+    /// Withdraw money from the account
+    let withdraw (account: BankAccount) (amount: int) : bool =
+        lock account.Lock (fun () ->
+            if account.Balance >= amount then
+                account.Balance <- account.Balance - amount
+                true
+            else
+                false
+        )
+```
+
+---
+
+## デッドロック回避
+
+```fsharp
+open System.Runtime.CompilerServices
+
+/// Transfer money between accounts atomically, avoiding deadlock
+let transfer (from: BankAccount) (toAccount: BankAccount) (amount: int) : bool =
+    // Always lock in consistent order to avoid deadlock
+    let fromHash = RuntimeHelpers.GetHashCode(from)
+    let toHash = RuntimeHelpers.GetHashCode(toAccount)
+    let (first, second) =
+        if fromHash < toHash then (from, toAccount)
+        else (toAccount, from)
+
+    lock first.Lock (fun () ->
+        lock second.Lock (fun () ->
+            if from.Balance >= amount then
+                from.Balance <- from.Balance - amount
+                toAccount.Balance <- toAccount.Balance + amount
+                true
+            else
+                false
+        )
+    )
+```
+
+---
+
+## F# の lock 関数
+
+```fsharp
+// F# の lock 関数は以下のパターンを簡潔に書ける
+lock lockObj (fun () ->
+    // クリティカルセクション
+    doSomething()
+)
+
+// これは以下と等価
+Monitor.Enter(lockObj)
+try
+    doSomething()
+finally
+    Monitor.Exit(lockObj)
+```
+
+---
+
+## 次のステップ
+
+[Part VI](part-6.md) では、ノンブロッキング I/O を学びます。

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

@@ -0,0 +1,93 @@
+---
+title: Part VI - ノンブロッキング I/O
+description: Async によるノンブロッキング処理
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, nio, async, fsharp
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VI: ノンブロッキング I/O
+
+## 概要
+
+本章では、F# の Async を使用したノンブロッキング I/O を学びます。
+
+---
+
+## ブロッキング vs ノンブロッキング
+
+### ブロッキング I/O
+
+```fsharp
+// スレッドは I/O 完了まで待機
+let content = File.ReadAllText("file.txt")
+```
+
+### ノンブロッキング I/O (Async)
+
+```fsharp
+let readFileAsync (path: string) : Async<string> =
+    async {
+        use reader = new StreamReader(path)
+        let! content = reader.ReadToEndAsync() |> Async.AwaitTask
+        return content
+    }
+```
+
+---
+
+## Async の基本
+
+```fsharp
+// 非同期計算を定義（実行されない）
+let fetchData (url: string) : Async<string> =
+    async {
+        use client = new HttpClient()
+        let! response = client.GetStringAsync(url) |> Async.AwaitTask
+        return response
+    }
+
+// 同期的に実行
+let result = Async.RunSynchronously (fetchData "https://example.com")
+
+// 非同期的に開始
+Async.Start (async {
+    let! result = fetchData "https://example.com"
+    printfn "%s" result
+})
+```
+
+---
+
+## 並列 Async
+
+```fsharp
+let downloadAll (urls: string list) : Async<string[]> =
+    urls
+    |> List.map fetchData
+    |> Async.Parallel
+
+// 使用例
+let results =
+    ["https://a.com"; "https://b.com"; "https://c.com"]
+    |> downloadAll
+    |> Async.RunSynchronously
+```
+
+---
+
+## メリット
+
+| 項目 | ブロッキング | Async |
+|------|-------------|-------|
+| スレッド消費 | 待機中も占有 | 解放 |
+| スケーラビリティ | 低い | 高い |
+| コード複雑さ | 低い | やや高い |
+
+---
+
+## 次のステップ
+
+[Part VII](part-7.md) では、Async ワークフローの詳細を学びます。

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

@@ -0,0 +1,121 @@
+---
+title: Part VII - 非同期プログラミング
+description: Async ワークフローによる非同期処理
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, async, fsharp
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VII: 非同期プログラミング
+
+## 概要
+
+本章では、F# の Async ワークフローを詳しく学びます。
+
+---
+
+## Async ワークフローの基本
+
+```fsharp
+// async { } 内で非同期計算を記述
+let computation : Async<int> =
+    async {
+        printfn "Starting..."
+        do! Async.Sleep(1000)
+        printfn "Done!"
+        return 42
+    }
+```
+
+---
+
+## let! と do!
+
+```fsharp
+let example : Async<int> =
+    async {
+        // let! : 値を取り出す
+        let! result = someAsyncComputation()
+
+        // do! : 値を無視
+        do! Async.Sleep(100)
+
+        return result * 2
+    }
+```
+
+---
+
+## 合成
+
+```fsharp
+// 順次実行
+let sequential : Async<int> =
+    async {
+        let! a = computeA()
+        let! b = computeB()
+        return a + b
+    }
+
+// 並列実行
+let parallel : Async<int[]> =
+    [computeA(); computeB(); computeC()]
+    |> Async.Parallel
+```
+
+---
+
+## エラーハンドリング
+
+```fsharp
+let safeComputation : Async<Result<int, string>> =
+    async {
+        try
+            let! result = riskyComputation()
+            return Ok result
+        with
+        | ex -> return Error ex.Message
+    }
+```
+
+---
+
+## キャンセル
+
+```fsharp
+let cancellableComputation (ct: CancellationToken) : Async<unit> =
+    async {
+        for i in 1 .. 100 do
+            ct.ThrowIfCancellationRequested()
+            do! Async.Sleep(100)
+            printfn $"Step {i}"
+    }
+
+// 使用例
+let cts = new CancellationTokenSource()
+Async.Start(cancellableComputation cts.Token)
+// キャンセル
+cts.Cancel()
+```
+
+---
+
+## Task との相互運用
+
+```fsharp
+// Task -> Async
+let asyncFromTask : Async<string> =
+    someTask |> Async.AwaitTask
+
+// Async -> Task
+let taskFromAsync : Task<string> =
+    someAsync |> Async.StartAsTask
+```
+
+---
+
+## 次のステップ
+
+[Part VIII](part-8.md) では、MapReduce パターンと並列配列を学びます。

package/lib/assets/docs/article/grokking-concurrency/fsharp/part-8.md

@@ -0,0 +1,107 @@
+---
+title: Part VIII - 分散並列処理
+description: MapReduce パターンと並列配列
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, mapreduce, parallel, fsharp
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part VIII: 分散並列処理
+
+## 概要
+
+本章では、MapReduce パターンと F# の並列配列を学びます。
+
+---
+
+## MapReduce パターン
+
+### ワードカウント実装
+
+```fsharp
+module WordCount =
+    /// Map: Convert text to (word, 1) pairs
+    let map (text: string) : (string * int) list =
+        text.ToLower().Split([|' '; '\t'; '\n'; '\r'|], StringSplitOptions.RemoveEmptyEntries)
+        |> Array.filter (fun s -> s.Length > 0)
+        |> Array.map (fun word -> (word, 1))
+        |> Array.toList
+
+    /// Reduce: Aggregate word counts
+    let reduce (pairs: (string * int) list) : Map<string, int> =
+        pairs
+        |> List.groupBy fst
+        |> List.map (fun (key, group) -> (key, group |> List.sumBy snd))
+        |> Map.ofList
+
+    /// MapReduce: Count words in multiple texts using parallel execution
+    let countWords (texts: string list) : Map<string, int> =
+        // Map phase (parallel)
+        let mapped =
+            texts
+            |> List.toArray
+            |> Array.Parallel.collect (fun text -> map text |> List.toArray)
+            |> Array.toList
+
+        // Reduce phase
+        reduce mapped
+```
+
+---
+
+## 使用例
+
+```fsharp
+let texts = [
+    "hello world"
+    "hello fsharp"
+    "world of fsharp"
+]
+
+let result = WordCount.countWords texts
+// Map [("hello", 2); ("world", 2); ("fsharp", 2); ("of", 1)]
+```
+
+---
+
+## Array.Parallel
+
+```fsharp
+// 並列 map
+let doubled = [|1..1000000|] |> Array.Parallel.map (fun x -> x * 2)
+
+// 並列 filter + map (collect)
+let processed =
+    data
+    |> Array.Parallel.collect (fun x ->
+        if x > 0 then [|x * 2|]
+        else [||]
+    )
+```
+
+---
+
+## まとめ
+
+本シリーズで学んだ内容:
+
+| Part | トピック | キーポイント |
+|------|----------|-------------|
+| I | 逐次処理 | 基本概念、パイプライン演算子 |
+| II | スレッド | Thread、Async.Parallel |
+| III | マルチタスキング | ゲームループ |
+| IV | 並列パターン | Fork/Join、Pipeline |
+| V | 同期 | lock、デッドロック回避 |
+| VI | ノンブロッキング | Async |
+| VII | 非同期 | Async ワークフロー |
+| VIII | 分散処理 | MapReduce、Array.Parallel |
+
+---
+
+## 参考資料
+
+- [F# Async Programming](https://docs.microsoft.com/ja-jp/dotnet/fsharp/tutorials/asynchronous-and-concurrent-programming/async)
+- [Array.Parallel Module](https://fsharp.github.io/fsharp-core-docs/reference/fsharp-collections-arraymodule-parallel.html)
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency)

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

@@ -0,0 +1,248 @@
+---
+title: index
+description: Haskell で学ぶ並行処理プログラミング
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, haskell
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Grokking Concurrency - Haskell 版
+
+本シリーズは「Grokking Concurrency」（Kirill Bobrov 著）の学習コンパニオンとして、並行処理プログラミングの概念を Haskell で実装しながら日本語で解説します。
+
+---
+
+## 対象読者
+
+- Haskell の基礎知識があり、並行処理に興味がある開発者
+- STM（Software Transactional Memory）を学びたい方
+- 純粋関数型言語での並行処理を理解したいエンジニア
+- async ライブラリや forkIO を使った並列処理に興味がある方
+
+---
+
+## 記事一覧
+
+### [Part I: 並行処理の基礎](part-1.md)
+
+逐次処理と並行処理の違い、基本概念を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第2章 | 逐次処理、パスワードクラッキング例 |
+
+**キーワード**: 逐次処理、純粋関数、Maybe モナド
+
+---
+
+### [Part II: プロセスとスレッド](part-2.md)
+
+スレッドの基本と async ライブラリを学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第4章 | forkIO、async、軽量スレッド |
+| 第5章 | 並列処理、mapConcurrently |
+
+**キーワード**: forkIO、async、Async
+
+---
+
+### [Part III: マルチタスキングとスケジューリング](part-3.md)
+
+マルチタスキングと STM を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第6章 | TVar、STM、ゲームループ |
+
+**キーワード**: STM、TVar、atomically
+
+---
+
+### [Part IV: タスク分解と並列パターン](part-4.md)
+
+並列処理のデザインパターンを学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第7章 | タスク分解、Fork/Join、パイプライン |
+
+**キーワード**: mapConcurrently、TQueue、Pipeline
+
+---
+
+### [Part V: 同期と排他制御](part-5.md)
+
+STM によるデッドロックフリーな同期を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第8章 | STM、TVar、アトミックトランザクション |
+
+**キーワード**: STM、atomically、retry
+
+---
+
+### [Part VI: ノンブロッキング I/O](part-6.md)
+
+ノンブロッキング I/O と非同期処理の基礎を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第10章 | IO モナド、非同期処理 |
+
+**キーワード**: IO、async、concurrently
+
+---
+
+### [Part VII: 非同期プログラミング](part-7.md)
+
+Haskell の async ライブラリを詳しく学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第12章 | async、wait、cancel、race |
+
+**キーワード**: Async、race、concurrently
+
+---
+
+### [Part VIII: 分散並列処理](part-8.md)
+
+MapReduce パターンと並列処理を学びます。
+
+| 章 | トピック |
+|----|----------|
+| 第13章 | MapReduce、ワードカウント |
+
+**キーワード**: MapReduce、mapConcurrently
+
+---
+
+## 使用ライブラリ
+
+| ライブラリ | 用途 | 対応章 |
+|------------|------|--------|
+| base | 基本ライブラリ | 全章 |
+| async | 非同期処理 | Part II-VIII |
+| stm | Software Transactional Memory | Part III, V |
+| cryptohash-sha256 | ハッシュ計算 | Part I, II |
+| containers | Map、Set | Part IV, VIII |
+
+---
+
+## リポジトリ構成
+
+```
+grokking_concurrency/
+├── apps/haskell/                  # Haskell サンプルコード
+│   ├── grokking-concurrency-haskell.cabal
+│   ├── stack.yaml
+│   └── src/
+│       ├── Ch02/PasswordCracker.hs
+│       ├── Ch04/ThreadBasics.hs
+│       ├── Ch05/PasswordCrackerParallel.hs
+│       ├── Ch06/GameLoop.hs
+│       ├── Ch07/VoteCounter.hs
+│       ├── Ch07/Pipeline.hs
+│       ├── Ch08/BankAccount.hs
+│       └── Ch13/WordCount.hs
+└── docs/article/haskell/          # 解説記事
+    ├── index.md
+    ├── part-1.md
+    └── ...
+```
+
+---
+
+## Haskell と並行処理
+
+Haskell は**純粋関数型言語**であり、並行処理に独自のアプローチを提供します。
+
+### forkIO（軽量スレッド）
+
+```haskell
+import Control.Concurrent (forkIO)
+
+main :: IO ()
+main = do
+    _ <- forkIO $ putStrLn "Hello from thread!"
+    putStrLn "Hello from main!"
+```
+
+### async ライブラリ
+
+```haskell
+import Control.Concurrent.Async
+
+main :: IO ()
+main = do
+    result <- async $ return (1 + 1)
+    value <- wait result
+    print value
+```
+
+### STM（Software Transactional Memory）
+
+```haskell
+import Control.Concurrent.STM
+
+main :: IO ()
+main = do
+    counter <- newTVarIO 0
+    atomically $ modifyTVar' counter (+1)
+    value <- readTVarIO counter
+    print value  -- 1
+```
+
+### 並列実行
+
+```haskell
+import Control.Concurrent.Async
+
+main :: IO ()
+main = do
+    results <- mapConcurrently id
+        [return 1, return 2, return 3]
+    print results  -- [1, 2, 3]
+```
+
+---
+
+## 主要な概念
+
+### IO モナドと純粋関数
+
+| 種類 | 説明 |
+|------|------|
+| 純粋関数 | 副作用なし、参照透過性 |
+| IO a | 副作用を持つ計算 |
+| STM a | トランザクショナルな計算 |
+
+### STM の特徴
+
+| 機能 | 説明 |
+|------|------|
+| atomically | トランザクションを実行 |
+| retry | 条件が満たされるまで待機 |
+| orElse | 代替トランザクション |
+| TVar | トランザクショナル変数 |
+
+### 並行処理の利点
+
+1. **デッドロックフリー** - STM による自動リトライ
+2. **型安全性** - コンパイル時の検証
+3. **合成可能性** - 小さな関数を組み合わせる
+4. **純粋性** - 副作用の明示的な管理
+
+---
+
+## 参考資料
+
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency) - 原著
+- [Parallel and Concurrent Programming in Haskell](https://simonmar.github.io/pages/pcph.html)
+- [async package](https://hackage.haskell.org/package/async)
+- [stm package](https://hackage.haskell.org/package/stm)