@k2works/claude-code-booster 6.2.0 → 6.3.0

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

@@ -1,103 +0,0 @@
----
-type: Article
-title: "Part V - 同期と排他制御"
-description: "銀行口座で学ぶロックとデッドロック回避"
-tags: [article, grokking-concurrency, fsharp, concurrency, synchronization, lock]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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

@@ -1,92 +0,0 @@
----
-type: Article
-title: "Part VI - ノンブロッキング I/O"
-description: "Async によるノンブロッキング処理"
-tags: [article, grokking-concurrency, fsharp, concurrency, nio, async]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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

@@ -1,120 +0,0 @@
----
-type: Article
-title: "Part VII - 非同期プログラミング"
-description: "Async ワークフローによる非同期処理"
-tags: [article, grokking-concurrency, fsharp, concurrency, async]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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

@@ -1,106 +0,0 @@
----
-type: Article
-title: "Part VIII - 分散並列処理"
-description: "MapReduce パターンと並列配列"
-tags: [article, grokking-concurrency, fsharp, concurrency, mapreduce, parallel]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 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

@@ -1,238 +0,0 @@
-# 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)