@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,84 @@
+---
+title: Part VII - 非同期プログラミング
+description: Task と async/await を使った非同期プログラミングを学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, task, async, csharp
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part VII: 非同期プログラミング
+
+## 概要
+
+本章では、C# の Task と async/await を使った非同期プログラミングを学びます。
+
+---
+
+## Task の基本
+
+### Task の作成
+
+```csharp
+var task = Task.Run(() => {
+    // 非同期処理
+    return "Result";
+});
+
+string result = await task;
+```
+
+### チェーン処理
+
+```csharp
+var result = await Task.Run(() => FetchData())
+    .ContinueWith(t => Process(t.Result))
+    .ContinueWith(t => Save(t.Result));
+```
+
+### 並行実行
+
+```csharp
+var task1 = Task.Run(() => FetchData1());
+var task2 = Task.Run(() => FetchData2());
+
+await Task.WhenAll(task1, task2);
+```
+
+---
+
+## ValueTask
+
+```csharp
+public ValueTask<int> GetCachedValueAsync()
+{
+    if (_cache.TryGetValue(key, out var value))
+        return new ValueTask<int>(value);
+
+    return new ValueTask<int>(FetchFromDatabaseAsync());
+}
+```
+
+---
+
+## 使い分けの指針
+
+| シナリオ | 推奨 |
+|----------|------|
+| I/O バウンド | async/await |
+| CPU バウンド | Task.Run / Parallel |
+| 混合 | async/await + Task.Run |
+
+---
+
+## 次のステップ
+
+Part VIII では、MapReduce パターンと PLINQ を学びます。
+
+---
+
+## 参考資料
+
+- [Task](https://docs.microsoft.com/ja-jp/dotnet/api/system.threading.tasks.task)
+- [ValueTask](https://docs.microsoft.com/ja-jp/dotnet/api/system.threading.tasks.valuetask-1)

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

@@ -0,0 +1,92 @@
+---
+title: Part VIII - 分散並列処理
+description: MapReduce パターンと PLINQ を学ぶ
+published: true
+date: 2025-12-30T09:00:00.000Z
+tags: concurrency, mapreduce, plinq, csharp
+editor: markdown
+dateCreated: 2025-12-30T09:00:00.000Z
+---
+
+# Part VIII: 分散並列処理
+
+## 概要
+
+本章では、MapReduce パターンと PLINQ を使った分散並列処理を学びます。
+
+---
+
+## MapReduce パターン
+
+### ワードカウントの例
+
+```csharp
+public static class WordCount
+{
+    // Map: テキストを (word, 1) のペアに変換
+    public static List<KeyValuePair<string, int>> Map(string text)
+    {
+        return text.ToLower()
+            .Split(' ', StringSplitOptions.RemoveEmptyEntries)
+            .Select(word => new KeyValuePair<string, int>(word, 1))
+            .ToList();
+    }
+
+    // Reduce: 同じ単語のカウントを集約
+    public static Dictionary<string, int> Reduce(List<KeyValuePair<string, int>> pairs)
+    {
+        return pairs
+            .GroupBy(p => p.Key)
+            .ToDictionary(g => g.Key, g => g.Sum(p => p.Value));
+    }
+
+    // MapReduce
+    public static Dictionary<string, int> CountWords(List<string> texts)
+    {
+        // Map フェーズ（並列）
+        var mapped = texts
+            .AsParallel()
+            .SelectMany(text => Map(text))
+            .ToList();
+
+        // Reduce フェーズ
+        return Reduce(mapped);
+    }
+}
+```
+
+---
+
+## PLINQ
+
+```csharp
+var result = data
+    .AsParallel()
+    .Where(x => x > 0)
+    .Select(x => x * 2)
+    .ToList();
+```
+
+---
+
+## まとめ
+
+本シリーズで学んだ内容:
+
+| Part | トピック | キーポイント |
+|------|----------|-------------|
+| I | 逐次処理 | 基本概念 |
+| II | スレッド | Thread, Task |
+| III | マルチタスキング | ゲームループ |
+| IV | 並列パターン | Fork/Join, Pipeline |
+| V | 同期 | lock, Monitor |
+| VI | ノンブロッキング | async/await |
+| VII | 非同期 | Task |
+| VIII | 分散処理 | MapReduce, PLINQ |
+
+---
+
+## 参考資料
+
+- [PLINQ](https://docs.microsoft.com/ja-jp/dotnet/standard/parallel-programming/introduction-to-plinq)
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency)

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

@@ -0,0 +1,65 @@
+---
+title: F# で学ぶ並行処理
+description: F# による並行処理プログラミング
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, fsharp, async
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# F# で学ぶ並行処理
+
+## 概要
+
+本シリーズでは、F# を使用して並行処理プログラミングの基礎から応用までを学びます。
+
+## 目次
+
+| Part | トピック | 内容 |
+|------|----------|------|
+| [Part I](part-1.md) | 逐次処理 | パスワードクラッキング、パフォーマンス |
+| [Part II](part-2.md) | スレッド | Thread、Async、並列実行 |
+| [Part III](part-3.md) | マルチタスキング | ゲームループ、タスクスケジューリング |
+| [Part IV](part-4.md) | 並列パターン | Fork/Join、パイプライン |
+| [Part V](part-5.md) | 同期と排他制御 | lock、デッドロック回避 |
+| [Part VI](part-6.md) | ノンブロッキング I/O | Async |
+| [Part VII](part-7.md) | 非同期プログラミング | Async ワークフロー |
+| [Part VIII](part-8.md) | 分散並列処理 | MapReduce、Array.Parallel |
+
+## 環境設定
+
+### 必要なツール
+
+- .NET 8.0 SDK
+- F# 8.0
+
+### プロジェクト構成
+
+```
+apps/fsharp/
+├── GrokkingConcurrency.FSharp.sln
+├── src/
+│   ├── Ch02/    # Part I
+│   ├── Ch04/    # Part II
+│   ├── Ch05/    # Part II
+│   ├── Ch06/    # Part III
+│   ├── Ch07/    # Part IV
+│   ├── Ch08/    # Part V
+│   └── Ch13/    # Part VIII
+└── tests/
+```
+
+### ビルドと実行
+
+```bash
+cd apps/fsharp
+dotnet build    # ビルド
+dotnet test     # テスト実行
+```
+
+## 参考資料
+
+- [Grokking Concurrency](https://www.manning.com/books/grokking-concurrency)
+- [F# Documentation](https://docs.microsoft.com/ja-jp/dotnet/fsharp/)
+- [F# Async Programming](https://docs.microsoft.com/ja-jp/dotnet/fsharp/tutorials/asynchronous-and-concurrent-programming/async)

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

@@ -0,0 +1,80 @@
+---
+title: Part I - 逐次処理
+description: パスワードクラッキングで学ぶ逐次処理の基礎
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, sequential, fsharp
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part I: 逐次処理
+
+## 概要
+
+本章では、パスワードクラッキングを例に逐次処理の基礎を学びます。
+
+---
+
+## パスワードクラッカーの実装
+
+### 組み合わせ生成
+
+```fsharp
+module PasswordCracker =
+    let private letters = "abcdefghijklmnopqrstuvwxyz"
+
+    /// Generate all combinations of lowercase letters of the given length
+    let getCombinations (length: int) : string list =
+        let rec generate (current: string list) (remaining: int) : string list =
+            if remaining = 0 then
+                current
+            else
+                let next =
+                    [ for prefix in current do
+                      for letter in letters do
+                          yield prefix + string letter ]
+                generate next (remaining - 1)
+        generate [""] length
+```
+
+### ハッシュ計算
+
+```fsharp
+open System.Security.Cryptography
+open System.Text
+
+/// Calculate SHA-256 hash of the given password
+let getCryptoHash (password: string) : string =
+    let bytes = Encoding.UTF8.GetBytes(password)
+    let hash = SHA256.HashData(bytes)
+    hash |> Array.map (fun b -> sprintf "%02x" b) |> String.concat ""
+```
+
+### パスワード解析
+
+```fsharp
+/// Check if the password matches the given hash
+let checkPassword (password: string) (cryptoHash: string) : bool =
+    getCryptoHash password = cryptoHash
+
+/// Crack password by brute force
+let crackPassword (cryptoHash: string) (length: int) : string option =
+    getCombinations length
+    |> List.tryFind (fun p -> checkPassword p cryptoHash)
+```
+
+---
+
+## F# の特徴
+
+- **パイプライン演算子 (`|>`)**: データの変換を読みやすく表現
+- **リスト内包表記**: `[ for x in xs do ... ]`
+- **Option 型**: null の代わりに `Option<string>` で結果を表現
+- **再帰関数**: `let rec` で再帰的に組み合わせを生成
+
+---
+
+## 次のステップ
+
+[Part II](part-2.md) では、スレッドと Async を使った並列処理を学びます。

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

@@ -0,0 +1,103 @@
+---
+title: Part II - プロセスとスレッド
+description: F# でのスレッド操作と並列パスワードクラッキング
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, threads, fsharp
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part II: プロセスとスレッド
+
+## 概要
+
+本章では、スレッドの基本操作と Async を使った並列パスワードクラッキングを実装します。
+
+---
+
+## スレッドの基本
+
+```fsharp
+open System.Threading
+
+module ThreadBasics =
+    /// Create a worker thread with the given name and task
+    let createWorker (name: string) (task: unit -> unit) : Thread =
+        let thread = Thread(ThreadStart(task))
+        thread.Name <- name
+        thread
+
+    /// Create multiple worker threads
+    let createMultipleWorkers (count: int) (task: int -> unit) : Thread list =
+        [ for i in 0 .. count - 1 do
+            let thread = Thread(ThreadStart(fun () -> task i))
+            thread.Name <- $"Worker-{i}"
+            yield thread ]
+
+    /// Start all threads and wait for them to complete
+    let startAndJoinAll (threads: Thread list) : unit =
+        threads |> List.iter (fun t -> t.Start())
+        threads |> List.iter (fun t -> t.Join())
+```
+
+---
+
+## 並列パスワードクラッキング
+
+### Async による並列実行
+
+```fsharp
+type ChunkRange = { Start: int; End: int }
+
+module PasswordCrackerParallel =
+    /// Divide a range into chunks
+    let getChunks (numChunks: int) (totalSize: int) : ChunkRange list =
+        let chunkSize = totalSize / numChunks
+        let remainder = totalSize % numChunks
+
+        [ for i in 0 .. numChunks - 1 do
+            let start = i * chunkSize + min i remainder
+            let extraOne = if i < remainder then 1 else 0
+            yield { Start = start; End = start + chunkSize + extraOne } ]
+
+    /// Crack password using parallel execution
+    let crackPasswordParallel (cryptoHash: string) (length: int) : string option =
+        let combinations = getCombinations length
+        let numCores = Environment.ProcessorCount
+        let chunks = getChunks numCores (List.length combinations)
+
+        let result = ref None
+        let combinationsArray = combinations |> List.toArray
+
+        let tasks =
+            chunks
+            |> List.map (fun chunk ->
+                async {
+                    let subList = combinationsArray.[chunk.Start .. chunk.End - 1]
+                    for password in subList do
+                        if Option.isNone !result && checkPassword password cryptoHash then
+                            result := Some password
+                })
+
+        tasks
+        |> Async.Parallel
+        |> Async.RunSynchronously
+        |> ignore
+
+        !result
+```
+
+---
+
+## ポイント
+
+- **Async ワークフロー**: `async { ... }` で非同期計算を定義
+- **Async.Parallel**: 複数の非同期計算を並列実行
+- **参照セル (`ref`)**: 可変な共有状態
+
+---
+
+## 次のステップ
+
+[Part III](part-3.md) では、マルチタスキングとゲームループを学びます。

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

@@ -0,0 +1,94 @@
+---
+title: Part III - マルチタスキングとスケジューリング
+description: ゲームループで学ぶマルチタスキング
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, multitasking, gameloop, fsharp
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part III: マルチタスキングとスケジューリング
+
+## 概要
+
+本章では、ゲームループを例にマルチタスキングとスケジューリングを学びます。
+
+---
+
+## ゲームタスク
+
+```fsharp
+type GameTask = { Name: string; Action: unit -> unit }
+
+module GameLoop =
+    /// Run a single task
+    let runTask (task: GameTask) : unit =
+        task.Action()
+```
+
+---
+
+## イベント同期
+
+```fsharp
+type ProcessorFreeEvent = {
+    Lock: obj
+    mutable Signaled: bool
+}
+
+module GameLoop =
+    /// Create a new processor free event
+    let createProcessorFreeEvent () : ProcessorFreeEvent =
+        { Lock = obj(); Signaled = false }
+
+    /// Wait for the event to be signaled
+    let waitForSignal (event: ProcessorFreeEvent) : unit =
+        lock event.Lock (fun () ->
+            while not event.Signaled do
+                Monitor.Wait(event.Lock) |> ignore
+        )
+
+    /// Signal the event
+    let signal (event: ProcessorFreeEvent) : unit =
+        lock event.Lock (fun () ->
+            event.Signaled <- true
+            Monitor.PulseAll(event.Lock)
+        )
+```
+
+---
+
+## ゲームループ
+
+```fsharp
+/// Run all tasks in a single frame
+let runOneFrame (tasks: GameTask list) : unit =
+    tasks |> List.iter runTask
+
+/// Run game loop for specified number of frames
+let run (tasks: GameTask list) (frames: int) : unit =
+    for frame in 1 .. frames do
+        printfn $"Frame {frame}"
+        runOneFrame tasks
+```
+
+---
+
+## 使用例
+
+```fsharp
+let tasks = [
+    { Name = "Input"; Action = fun () -> printfn "Processing input..." }
+    { Name = "Update"; Action = fun () -> printfn "Updating game state..." }
+    { Name = "Render"; Action = fun () -> printfn "Rendering frame..." }
+]
+
+GameLoop.run tasks 3
+```
+
+---
+
+## 次のステップ
+
+[Part IV](part-4.md) では、Fork/Join パターンとパイプラインを学びます。

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

@@ -0,0 +1,110 @@
+---
+title: Part IV - タスク分解と並列パターン
+description: Fork/Join パターンとパイプラインパターン
+published: true
+date: 2025-12-31T10:00:00.000Z
+tags: concurrency, fork-join, pipeline, fsharp
+editor: markdown
+dateCreated: 2025-12-31T10:00:00.000Z
+---
+
+# Part IV: タスク分解と並列パターン
+
+## 概要
+
+本章では、Fork/Join パターンとパイプラインパターンを学びます。
+
+---
+
+## Fork/Join パターン: 投票カウンター
+
+### 逐次カウント
+
+```fsharp
+module VoteCounter =
+    /// Count votes sequentially
+    let countVotes (votes: string list) : Map<string, int> =
+        votes
+        |> List.groupBy id
+        |> List.map (fun (key, group) -> (key, List.length group))
+        |> Map.ofList
+
+    /// Merge two vote count results
+    let mergeResults (a: Map<string, int>) (b: Map<string, int>) : Map<string, int> =
+        let allKeys = Set.union (Map.keys a |> Set.ofSeq) (Map.keys b |> Set.ofSeq)
+        allKeys
+        |> Set.toList
+        |> List.map (fun key ->
+            let countA = Map.tryFind key a |> Option.defaultValue 0
+            let countB = Map.tryFind key b |> Option.defaultValue 0
+            (key, countA + countB))
+        |> Map.ofList
+```
+
+### 並列カウント
+
+```fsharp
+/// Count votes using fork-join pattern
+let countVotesParallel (votes: string list) : Map<string, int> =
+    if List.isEmpty votes then
+        Map.empty
+    else
+        let numCores = Environment.ProcessorCount
+        let chunkSize = max 1 (List.length votes / numCores)
+        let chunks = votes |> List.chunkBySize chunkSize
+
+        let results =
+            chunks
+            |> List.map (fun chunk -> async { return countVotes chunk })
+            |> Async.Parallel
+            |> Async.RunSynchronously
+            |> Array.toList
+
+        results |> List.reduce mergeResults
+```
+
+---
+
+## パイプラインパターン
+
+```fsharp
+type Stage = { Name: string; Processor: obj -> obj }
+type Pipeline<'T> = { Stages: Stage list }
+
+module Pipeline =
+    let createPipeline<'T> : Pipeline<'T> =
+        { Stages = [] }
+
+    let addStage (name: string) (processor: obj -> obj) (pipeline: Pipeline<'T>) : Pipeline<'T> =
+        { pipeline with Stages = pipeline.Stages @ [{ Name = name; Processor = processor }] }
+
+    let run (pipeline: Pipeline<'T>) (data: 'T list) : obj list =
+        if List.isEmpty pipeline.Stages then
+            data |> List.map (fun x -> x :> obj)
+        else
+            data
+            |> List.map (fun item ->
+                pipeline.Stages
+                |> List.fold (fun current stage -> stage.Processor current) (item :> obj)
+            )
+```
+
+---
+
+## 使用例
+
+```fsharp
+let pipeline =
+    Pipeline.createPipeline<int>
+    |> Pipeline.addStage "double" (fun x -> (x :?> int) * 2 :> obj)
+    |> Pipeline.addStage "addOne" (fun x -> (x :?> int) + 1 :> obj)
+
+let results = Pipeline.run pipeline [1; 2; 3]
+// [3; 5; 7]
+```
+
+---
+
+## 次のステップ
+
+[Part V](part-5.md) では、同期と排他制御を学びます。