@k2works/claude-code-booster 4.8.0 → 4.11.0

package/lib/assets/docs/article/grokking-concurrency/all/part-4-ch07-parallel-patterns.md

@@ -1,420 +1,420 @@
-# Part IV: タスク分解と並列パターン
-
-## 4.1 はじめに
-
-Part III でマルチタスキングの仕組みを学びました。本章では、複雑な問題を並列に処理するための 2 つの基本パターン — **Fork/Join** と **Pipeline** — を学びます。投票集計と洗濯パイプラインを題材に、8 つの言語での実装を比較します。
-
-### データ並列 vs タスク並列
-
-| パターン | 説明 | 例 |
-|---------|------|-----|
-| データ並列 | 同じ操作を複数のデータに適用 | 配列の各要素を 2 倍にする |
-| タスク並列 | 異なる操作を同時に実行 | Input → Compute → Output |
-
-## 4.2 共通の本質
-
-### Fork/Join パターン
-
-```
-入力データ
-    ↓
-  [Fork] ── 分割 ──→ [Worker 1] [Worker 2] [Worker 3]
-                         ↓          ↓          ↓
-                      部分結果1   部分結果2   部分結果3
-                         ↓          ↓          ↓
-  [Join] ── 統合 ──→ 最終結果
-```
-
-**3 つのフェーズ**:
-
-1. **Fork**: データをチャンクに分割し、各ワーカーに配布
-2. **Process**: 各ワーカーが独立して部分結果を計算
-3. **Join**: 部分結果を統合して最終結果を生成
-
-### Pipeline パターン
-
-```
-[Stage 1: 洗濯] →→ [Stage 2: 乾燥] →→ [Stage 3: 畳み]
-     ↓ Queue          ↓ Queue          ↓
-   Load 1           Load 1           Load 1
-   Load 2           Load 2           Load 2
-   Load 3           Load 3           Load 3
-```
-
-各ステージが独立したスレッドで動作し、キューを介して次のステージにデータを渡します。逐次処理では 28 秒かかる 4 回の洗濯が、パイプラインでは約 19 秒に短縮されます。
-
-## 4.3 言語別実装比較
-
-### Fork/Join: 投票集計
-
-#### 関数型ファースト言語
-
-<details>
-<summary>Haskell 実装</summary>
-
-```haskell
-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
-```
-
-**特徴**:
-
-- `mapConcurrently` でチャンクごとに並列集計
-- `Map.unionWith (+)` で部分結果をマージ
-- 純粋関数 `countVotes` は副作用なし
-
-</details>
-
-<details>
-<summary>Clojure 実装</summary>
-
-```clojure
-(defn count-votes-parallel [votes num-workers]
-  (if (empty? votes)
-    {}
-    (let [chunks (partition-all (max 1 (quot (count votes) num-workers)) votes)
-          futures (doall (map #(future (count-votes-sequential %)) chunks))
-          results (map deref futures)]
-      (merge-counts results))))
-```
-
-**特徴**:
-
-- `partition-all` でデータを均等分割
-- `future` + `deref` で非同期実行と結果取得
-- `merge-with +` で部分結果をマージ
-
-</details>
-
-#### マルチパラダイム言語
-
-<details>
-<summary>Rust 実装（Rayon）</summary>
-
-```rust
-pub fn count_votes(votes: &[&str]) -> HashMap<String, usize> {
-    votes
-        .par_iter()
-        .fold(
-            || HashMap::new(),
-            |mut acc, &vote| {
-                *acc.entry(vote.to_string()).or_insert(0) += 1;
-                acc
-            },
-        )
-        .reduce(
-            || HashMap::new(),
-            |mut a, b| {
-                for (k, v) in b {
-                    *a.entry(k).or_insert(0) += v;
-                }
-                a
-            },
-        )
-}
-```
-
-**特徴**:
-
-- `par_iter()` + `fold` + `reduce` のワンパス並列処理
-- 明示的なチャンク分割が不要（Rayon が自動分配）
-- `entry` API でハッシュマップを安全に更新
-
-</details>
-
-<details>
-<summary>Scala 実装</summary>
-
-```scala
-def countVotesParallel(votes: List[String]): Map[String, Int] =
-  val numCores = Runtime.getRuntime.availableProcessors()
-  val chunks = votes.grouped(math.max(1, votes.size / numCores)).toList
-
-  val futures = chunks.map { chunk =>
-    Future(countVotes(chunk))
-  }
-
-  val results = futures.map(f => Await.result(f, Duration.Inf))
-  results.reduce(mergeResults)
-```
-
-**特徴**:
-
-- `grouped` でコレクションを均等分割
-- `Future` + `Await.result` で非同期実行
-- `reduce(mergeResults)` で部分結果を統合
-
-</details>
-
-<details>
-<summary>F# 実装</summary>
-
-```fsharp
-let countVotesParallel (votes: string list) : Map<string, int> =
-    let numCores = Environment.ProcessorCount
-    let chunks = votes |> List.chunkBySize (max 1 (List.length votes / numCores))
-
-    let results =
-        chunks
-        |> List.map (fun chunk -> async { return countVotes chunk })
-        |> Async.Parallel
-        |> Async.RunSynchronously
-        |> Array.toList
-
-    results |> List.reduce mergeResults
-```
-
-**特徴**:
-
-- `List.chunkBySize` で均等分割
-- `Async.Parallel` で並列実行
-- パイプ演算子 `|>` で変換フローを明示
-
-</details>
-
-#### OOP + 並行処理ライブラリ言語
-
-<details>
-<summary>Java 実装</summary>
-
-```java
-public static Map<Integer, Integer> countVotesParallel(
-    List<Integer> votes, int numWorkers) {
-    int chunkSize = (int) Math.ceil((double) votes.size() / numWorkers);
-    List<List<Integer>> chunks = new ArrayList<>();
-    for (int i = 0; i < votes.size(); i += chunkSize) {
-        chunks.add(votes.subList(i, Math.min(i + chunkSize, votes.size())));
-    }
-
-    try (ExecutorService executor = Executors.newFixedThreadPool(numWorkers)) {
-        List<Future<Map<Integer, Integer>>> futures = new ArrayList<>();
-        for (List<Integer> chunk : chunks) {
-            futures.add(executor.submit(() -> countVotes(chunk)));
-        }
-
-        Map<Integer, Integer> total = new HashMap<>();
-        for (Future<Map<Integer, Integer>> future : futures) {
-            total = mergeResults(total, future.get());
-        }
-        return total;
-    }
-}
-```
-
-**特徴**:
-
-- `ExecutorService` でスレッドプールを管理
-- `Future.get()` で結果をブロッキング取得
-- `merge()` ユーティリティで結果を統合
-
-</details>
-
-<details>
-<summary>C# 実装</summary>
-
-```csharp
-public static Dictionary<int, int> CountVotesParallel(
-    List<int> votes, int numWorkers) {
-    var chunkSize = (int)Math.Ceiling((double)votes.Count / numWorkers);
-    var chunks = new List<List<int>>();
-    for (var i = 0; i < votes.Count; i += chunkSize)
-        chunks.Add(votes.GetRange(i, Math.Min(chunkSize, votes.Count - i)));
-
-    var tasks = chunks.Select(chunk =>
-        Task.Run(() => CountVotes(chunk))
-    ).ToArray();
-
-    Task.WaitAll(tasks);
-    return tasks.Aggregate(new Dictionary<int, int>(),
-        (acc, t) => MergeResults(acc, t.Result));
-}
-```
-
-**特徴**:
-
-- `Task.Run()` で並列タスクを生成
-- LINQ `Aggregate` で結果をマージ
-- `Task.WaitAll` で全タスクの完了を待機
-
-</details>
-
-### Pipeline: 洗濯パイプライン
-
-#### チャネル/キューの比較
-
-| 言語 | メカニズム | 送信 | 受信 |
-|------|----------|------|------|
-| Python | `queue.Queue` | `put()` | `get()` |
-| Java | `BlockingQueue` | `offer()` / `put()` | `poll()` / `take()` |
-| C# | `BlockingCollection<T>` | `TryAdd()` | `TryTake()` |
-| Rust | `mpsc::channel` | `send()` | `recv()` |
-| Haskell | `TQueue` (STM) | `writeTQueue` | `readTQueue` |
-| Clojure | `core.async chan` | `>!` / `>!!` | `<!` / `<!!` |
-| Scala | `LinkedBlockingQueue` | `offer()` | `poll()` |
-| F# | `Async` ワークフロー | 関数合成 | 関数合成 |
-
-<details>
-<summary>Rust 実装（mpsc チャネル）</summary>
-
-```rust
-pub fn concurrent_pipeline<T>(
-    input: Vec<T>,
-    processors: Vec<Box<dyn Fn(T) -> T + Send + 'static>>,
-) -> Vec<T>
-where
-    T: Send + 'static + Clone,
-{
-    let (first_tx, mut current_rx) = channel();
-
-    let input_thread = thread::spawn(move || {
-        for item in input {
-            first_tx.send(item).unwrap();
-        }
-    });
-
-    let mut handles = vec![input_thread];
-
-    for processor in processors {
-        let (tx, rx) = channel();
-        let prev_rx = current_rx;
-        current_rx = rx;
-
-        let handle = thread::spawn(move || {
-            while let Ok(item) = prev_rx.recv() {
-                let result = processor(item);
-                if tx.send(result).is_err() { break; }
-            }
-        });
-        handles.push(handle);
-    }
-
-    let mut results = Vec::new();
-    while let Ok(item) = current_rx.recv() {
-        results.push(item);
-    }
-
-    for handle in handles { handle.join().unwrap(); }
-    results
-}
-```
-
-</details>
-
-<details>
-<summary>Clojure 実装（core.async）</summary>
-
-```clojure
-(defn run-chain-pipeline [initial-value functions]
-  (if (empty? functions)
-    initial-value
-    (let [channels (repeatedly (inc (count functions)) #(chan 1))]
-      (doseq [[in-ch out-ch f] (map vector channels (rest channels) functions)]
-        (go
-          (when-let [v (<! in-ch)]
-            (>! out-ch (f v)))))
-      (>!! (first channels) initial-value)
-      (<!! (last channels)))))
-```
-
-</details>
-
-<details>
-<summary>Haskell 実装（TQueue）</summary>
-
-```haskell
-concurrentPipeline :: [a -> a] -> [a] -> IO [a]
-concurrentPipeline processors inputs = do
-    queues <- forM [1..length processors + 1] $ \_ -> newTQueueIO
-
-    forkIO $ do
-        mapM_ (atomically . writeTQueue (head queues) . Just) inputs
-        atomically $ writeTQueue (head queues) Nothing
-
-    let pairs = zip3 (init queues) (tail queues) processors
-    mapM_ (\(inQ, outQ, proc) -> forkIO $ processStage inQ outQ proc) pairs
-
-    collectResults (last queues)
-```
-
-</details>
-
-## 4.4 比較分析
-
-### Fork/Join の実装パターン
-
-| パターン | 言語 | 特徴 |
-|---------|------|------|
-| 自動分配 | Rust (Rayon) | `par_iter()` がチャンク分割・負荷分散を自動化 |
-| アプリカティブ並列 | Haskell | `mapConcurrently` で要素ごとに並列化 |
-| Future 分散 | Java, Scala, Clojure | チャンク分割 → Future 生成 → 結果統合 |
-| Async 並列 | F# | `Async.Parallel` で宣言的に並列実行 |
-| Task 分散 | C# | `Task.Run()` + `Task.WaitAll` |
-| プロセスプール | Python | `multiprocessing.Pool` で GIL を回避 |
-
-### 結果マージの方法
-
-| 言語 | マージ関数 | 特徴 |
-|------|----------|------|
-| Python | `dict` + ループ | 手動マージ |
-| Java | `HashMap.merge()` | `Integer::sum` で関数的 |
-| C# | LINQ `Aggregate` | 宣言的 |
-| Scala | `reduce(mergeResults)` | 関数型 |
-| F# | `List.reduce mergeResults` | パイプライン |
-| Rust | `reduce` + `entry` API | ロックフリー |
-| Haskell | `foldl' (Map.unionWith (+))` | 純粋関数型 |
-| Clojure | `merge-with +` | 最も簡潔 |
-
-### Pipeline の設計思想
-
-| 言語 | キュー方式 | 通信モデル |
-|------|----------|-----------|
-| Python | `queue.Queue` | ブロッキング |
-| Java | `BlockingQueue` | ブロッキング（タイムアウト付き） |
-| C# | `BlockingCollection` | ブロッキング（キャンセル対応） |
-| Rust | `mpsc::channel` | 所有権ベース |
-| Haskell | `TQueue` (STM) | トランザクショナル |
-| Clojure | `core.async chan` | CSP モデル（go ブロック） |
-
-## 4.5 実践的な選択指針
-
-### Fork/Join に適した言語
-
-- **Rust (Rayon)** — `par_iter()` で最小限のコード変更で並列化。ワークスティーリングによる自動負荷分散
-- **Haskell** — 純粋関数は安全に並列実行可能。`mapConcurrently` が宣言的
-- **Clojure** — `merge-with +` が最も簡潔なマージ表現
-
-### Pipeline に適した言語
-
-- **Clojure (core.async)** — CSP モデルでチャネルベースのパイプラインを自然に表現
-- **Rust** — `mpsc` チャネルで型安全なステージ間通信
-- **Haskell** — STM ベースの `TQueue` でデッドロックフリー
-
-## 4.6 まとめ
-
-### 言語横断的な学び
-
-1. **Fork/Join は map-reduce の基礎** — データ分割→並列処理→統合は全言語共通
-2. **Pipeline はキュー設計が鍵** — ステージ間通信のメカニズムが言語の個性を決定
-3. **抽象度の違い** — Rayon の自動分配 vs 手動チャンク分割の選択
-4. **マージ操作の表現力** — `merge-with +` (Clojure) から `HashMap.merge()` (Java) まで
-
-### 次のステップ
-
-[Part VIII: 分散並列処理](./part-8-ch13-mapreduce.md) では、MapReduce パターンを使って大規模データの並列処理を学びます。
-
-### 各言語の個別記事
-
-| 言語 | 個別記事 |
-|------|---------|
-| Python | [Part IV - タスク分解と並列パターン](../python/part-4.md) |
-| Java | [Part IV - タスク分解と並列パターン](../java/part-4.md) |
-| C# | [Part IV - タスク分解と並列パターン](../csharp/part-4.md) |
-| Scala | [Part IV - タスク分解と並列パターン](../scala/part-4.md) |
-| F# | [Part IV - タスク分解と並列パターン](../fsharp/part-4.md) |
-| Rust | [Part IV - タスク分解と並列パターン](../rust/part-4.md) |
-| Haskell | [Part IV - タスク分解と並列パターン](../haskell/part-4.md) |
-| Clojure | [Part IV - タスク分解と並列パターン](../clojure/part-4.md) |
+# Part IV: タスク分解と並列パターン
+
+## 4.1 はじめに
+
+Part III でマルチタスキングの仕組みを学びました。本章では、複雑な問題を並列に処理するための 2 つの基本パターン — **Fork/Join** と **Pipeline** — を学びます。投票集計と洗濯パイプラインを題材に、8 つの言語での実装を比較します。
+
+### データ並列 vs タスク並列
+
+| パターン | 説明 | 例 |
+|---------|------|-----|
+| データ並列 | 同じ操作を複数のデータに適用 | 配列の各要素を 2 倍にする |
+| タスク並列 | 異なる操作を同時に実行 | Input → Compute → Output |
+
+## 4.2 共通の本質
+
+### Fork/Join パターン
+
+```
+入力データ
+    ↓
+  [Fork] ── 分割 ──→ [Worker 1] [Worker 2] [Worker 3]
+                         ↓          ↓          ↓
+                      部分結果1   部分結果2   部分結果3
+                         ↓          ↓          ↓
+  [Join] ── 統合 ──→ 最終結果
+```
+
+**3 つのフェーズ**:
+
+1. **Fork**: データをチャンクに分割し、各ワーカーに配布
+2. **Process**: 各ワーカーが独立して部分結果を計算
+3. **Join**: 部分結果を統合して最終結果を生成
+
+### Pipeline パターン
+
+```
+[Stage 1: 洗濯] →→ [Stage 2: 乾燥] →→ [Stage 3: 畳み]
+     ↓ Queue          ↓ Queue          ↓
+   Load 1           Load 1           Load 1
+   Load 2           Load 2           Load 2
+   Load 3           Load 3           Load 3
+```
+
+各ステージが独立したスレッドで動作し、キューを介して次のステージにデータを渡します。逐次処理では 28 秒かかる 4 回の洗濯が、パイプラインでは約 19 秒に短縮されます。
+
+## 4.3 言語別実装比較
+
+### Fork/Join: 投票集計
+
+#### 関数型ファースト言語
+
+<details>
+<summary>Haskell 実装</summary>
+
+```haskell
+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
+```
+
+**特徴**:
+
+- `mapConcurrently` でチャンクごとに並列集計
+- `Map.unionWith (+)` で部分結果をマージ
+- 純粋関数 `countVotes` は副作用なし
+
+</details>
+
+<details>
+<summary>Clojure 実装</summary>
+
+```clojure
+(defn count-votes-parallel [votes num-workers]
+  (if (empty? votes)
+    {}
+    (let [chunks (partition-all (max 1 (quot (count votes) num-workers)) votes)
+          futures (doall (map #(future (count-votes-sequential %)) chunks))
+          results (map deref futures)]
+      (merge-counts results))))
+```
+
+**特徴**:
+
+- `partition-all` でデータを均等分割
+- `future` + `deref` で非同期実行と結果取得
+- `merge-with +` で部分結果をマージ
+
+</details>
+
+#### マルチパラダイム言語
+
+<details>
+<summary>Rust 実装（Rayon）</summary>
+
+```rust
+pub fn count_votes(votes: &[&str]) -> HashMap<String, usize> {
+    votes
+        .par_iter()
+        .fold(
+            || HashMap::new(),
+            |mut acc, &vote| {
+                *acc.entry(vote.to_string()).or_insert(0) += 1;
+                acc
+            },
+        )
+        .reduce(
+            || HashMap::new(),
+            |mut a, b| {
+                for (k, v) in b {
+                    *a.entry(k).or_insert(0) += v;
+                }
+                a
+            },
+        )
+}
+```
+
+**特徴**:
+
+- `par_iter()` + `fold` + `reduce` のワンパス並列処理
+- 明示的なチャンク分割が不要（Rayon が自動分配）
+- `entry` API でハッシュマップを安全に更新
+
+</details>
+
+<details>
+<summary>Scala 実装</summary>
+
+```scala
+def countVotesParallel(votes: List[String]): Map[String, Int] =
+  val numCores = Runtime.getRuntime.availableProcessors()
+  val chunks = votes.grouped(math.max(1, votes.size / numCores)).toList
+
+  val futures = chunks.map { chunk =>
+    Future(countVotes(chunk))
+  }
+
+  val results = futures.map(f => Await.result(f, Duration.Inf))
+  results.reduce(mergeResults)
+```
+
+**特徴**:
+
+- `grouped` でコレクションを均等分割
+- `Future` + `Await.result` で非同期実行
+- `reduce(mergeResults)` で部分結果を統合
+
+</details>
+
+<details>
+<summary>F# 実装</summary>
+
+```fsharp
+let countVotesParallel (votes: string list) : Map<string, int> =
+    let numCores = Environment.ProcessorCount
+    let chunks = votes |> List.chunkBySize (max 1 (List.length votes / numCores))
+
+    let results =
+        chunks
+        |> List.map (fun chunk -> async { return countVotes chunk })
+        |> Async.Parallel
+        |> Async.RunSynchronously
+        |> Array.toList
+
+    results |> List.reduce mergeResults
+```
+
+**特徴**:
+
+- `List.chunkBySize` で均等分割
+- `Async.Parallel` で並列実行
+- パイプ演算子 `|>` で変換フローを明示
+
+</details>
+
+#### OOP + 並行処理ライブラリ言語
+
+<details>
+<summary>Java 実装</summary>
+
+```java
+public static Map<Integer, Integer> countVotesParallel(
+    List<Integer> votes, int numWorkers) {
+    int chunkSize = (int) Math.ceil((double) votes.size() / numWorkers);
+    List<List<Integer>> chunks = new ArrayList<>();
+    for (int i = 0; i < votes.size(); i += chunkSize) {
+        chunks.add(votes.subList(i, Math.min(i + chunkSize, votes.size())));
+    }
+
+    try (ExecutorService executor = Executors.newFixedThreadPool(numWorkers)) {
+        List<Future<Map<Integer, Integer>>> futures = new ArrayList<>();
+        for (List<Integer> chunk : chunks) {
+            futures.add(executor.submit(() -> countVotes(chunk)));
+        }
+
+        Map<Integer, Integer> total = new HashMap<>();
+        for (Future<Map<Integer, Integer>> future : futures) {
+            total = mergeResults(total, future.get());
+        }
+        return total;
+    }
+}
+```
+
+**特徴**:
+
+- `ExecutorService` でスレッドプールを管理
+- `Future.get()` で結果をブロッキング取得
+- `merge()` ユーティリティで結果を統合
+
+</details>
+
+<details>
+<summary>C# 実装</summary>
+
+```csharp
+public static Dictionary<int, int> CountVotesParallel(
+    List<int> votes, int numWorkers) {
+    var chunkSize = (int)Math.Ceiling((double)votes.Count / numWorkers);
+    var chunks = new List<List<int>>();
+    for (var i = 0; i < votes.Count; i += chunkSize)
+        chunks.Add(votes.GetRange(i, Math.Min(chunkSize, votes.Count - i)));
+
+    var tasks = chunks.Select(chunk =>
+        Task.Run(() => CountVotes(chunk))
+    ).ToArray();
+
+    Task.WaitAll(tasks);
+    return tasks.Aggregate(new Dictionary<int, int>(),
+        (acc, t) => MergeResults(acc, t.Result));
+}
+```
+
+**特徴**:
+
+- `Task.Run()` で並列タスクを生成
+- LINQ `Aggregate` で結果をマージ
+- `Task.WaitAll` で全タスクの完了を待機
+
+</details>
+
+### Pipeline: 洗濯パイプライン
+
+#### チャネル/キューの比較
+
+| 言語 | メカニズム | 送信 | 受信 |
+|------|----------|------|------|
+| Python | `queue.Queue` | `put()` | `get()` |
+| Java | `BlockingQueue` | `offer()` / `put()` | `poll()` / `take()` |
+| C# | `BlockingCollection<T>` | `TryAdd()` | `TryTake()` |
+| Rust | `mpsc::channel` | `send()` | `recv()` |
+| Haskell | `TQueue` (STM) | `writeTQueue` | `readTQueue` |
+| Clojure | `core.async chan` | `>!` / `>!!` | `<!` / `<!!` |
+| Scala | `LinkedBlockingQueue` | `offer()` | `poll()` |
+| F# | `Async` ワークフロー | 関数合成 | 関数合成 |
+
+<details>
+<summary>Rust 実装（mpsc チャネル）</summary>
+
+```rust
+pub fn concurrent_pipeline<T>(
+    input: Vec<T>,
+    processors: Vec<Box<dyn Fn(T) -> T + Send + 'static>>,
+) -> Vec<T>
+where
+    T: Send + 'static + Clone,
+{
+    let (first_tx, mut current_rx) = channel();
+
+    let input_thread = thread::spawn(move || {
+        for item in input {
+            first_tx.send(item).unwrap();
+        }
+    });
+
+    let mut handles = vec![input_thread];
+
+    for processor in processors {
+        let (tx, rx) = channel();
+        let prev_rx = current_rx;
+        current_rx = rx;
+
+        let handle = thread::spawn(move || {
+            while let Ok(item) = prev_rx.recv() {
+                let result = processor(item);
+                if tx.send(result).is_err() { break; }
+            }
+        });
+        handles.push(handle);
+    }
+
+    let mut results = Vec::new();
+    while let Ok(item) = current_rx.recv() {
+        results.push(item);
+    }
+
+    for handle in handles { handle.join().unwrap(); }
+    results
+}
+```
+
+</details>
+
+<details>
+<summary>Clojure 実装（core.async）</summary>
+
+```clojure
+(defn run-chain-pipeline [initial-value functions]
+  (if (empty? functions)
+    initial-value
+    (let [channels (repeatedly (inc (count functions)) #(chan 1))]
+      (doseq [[in-ch out-ch f] (map vector channels (rest channels) functions)]
+        (go
+          (when-let [v (<! in-ch)]
+            (>! out-ch (f v)))))
+      (>!! (first channels) initial-value)
+      (<!! (last channels)))))
+```
+
+</details>
+
+<details>
+<summary>Haskell 実装（TQueue）</summary>
+
+```haskell
+concurrentPipeline :: [a -> a] -> [a] -> IO [a]
+concurrentPipeline processors inputs = do
+    queues <- forM [1..length processors + 1] $ \_ -> newTQueueIO
+
+    forkIO $ do
+        mapM_ (atomically . writeTQueue (head queues) . Just) inputs
+        atomically $ writeTQueue (head queues) Nothing
+
+    let pairs = zip3 (init queues) (tail queues) processors
+    mapM_ (\(inQ, outQ, proc) -> forkIO $ processStage inQ outQ proc) pairs
+
+    collectResults (last queues)
+```
+
+</details>
+
+## 4.4 比較分析
+
+### Fork/Join の実装パターン
+
+| パターン | 言語 | 特徴 |
+|---------|------|------|
+| 自動分配 | Rust (Rayon) | `par_iter()` がチャンク分割・負荷分散を自動化 |
+| アプリカティブ並列 | Haskell | `mapConcurrently` で要素ごとに並列化 |
+| Future 分散 | Java, Scala, Clojure | チャンク分割 → Future 生成 → 結果統合 |
+| Async 並列 | F# | `Async.Parallel` で宣言的に並列実行 |
+| Task 分散 | C# | `Task.Run()` + `Task.WaitAll` |
+| プロセスプール | Python | `multiprocessing.Pool` で GIL を回避 |
+
+### 結果マージの方法
+
+| 言語 | マージ関数 | 特徴 |
+|------|----------|------|
+| Python | `dict` + ループ | 手動マージ |
+| Java | `HashMap.merge()` | `Integer::sum` で関数的 |
+| C# | LINQ `Aggregate` | 宣言的 |
+| Scala | `reduce(mergeResults)` | 関数型 |
+| F# | `List.reduce mergeResults` | パイプライン |
+| Rust | `reduce` + `entry` API | ロックフリー |
+| Haskell | `foldl' (Map.unionWith (+))` | 純粋関数型 |
+| Clojure | `merge-with +` | 最も簡潔 |
+
+### Pipeline の設計思想
+
+| 言語 | キュー方式 | 通信モデル |
+|------|----------|-----------|
+| Python | `queue.Queue` | ブロッキング |
+| Java | `BlockingQueue` | ブロッキング（タイムアウト付き） |
+| C# | `BlockingCollection` | ブロッキング（キャンセル対応） |
+| Rust | `mpsc::channel` | 所有権ベース |
+| Haskell | `TQueue` (STM) | トランザクショナル |
+| Clojure | `core.async chan` | CSP モデル（go ブロック） |
+
+## 4.5 実践的な選択指針
+
+### Fork/Join に適した言語
+
+- **Rust (Rayon)** — `par_iter()` で最小限のコード変更で並列化。ワークスティーリングによる自動負荷分散
+- **Haskell** — 純粋関数は安全に並列実行可能。`mapConcurrently` が宣言的
+- **Clojure** — `merge-with +` が最も簡潔なマージ表現
+
+### Pipeline に適した言語
+
+- **Clojure (core.async)** — CSP モデルでチャネルベースのパイプラインを自然に表現
+- **Rust** — `mpsc` チャネルで型安全なステージ間通信
+- **Haskell** — STM ベースの `TQueue` でデッドロックフリー
+
+## 4.6 まとめ
+
+### 言語横断的な学び
+
+1. **Fork/Join は map-reduce の基礎** — データ分割→並列処理→統合は全言語共通
+2. **Pipeline はキュー設計が鍵** — ステージ間通信のメカニズムが言語の個性を決定
+3. **抽象度の違い** — Rayon の自動分配 vs 手動チャンク分割の選択
+4. **マージ操作の表現力** — `merge-with +` (Clojure) から `HashMap.merge()` (Java) まで
+
+### 次のステップ
+
+[Part VIII: 分散並列処理](./part-8-ch13-mapreduce.md) では、MapReduce パターンを使って大規模データの並列処理を学びます。
+
+### 各言語の個別記事
+
+| 言語 | 個別記事 |
+|------|---------|
+| Python | [Part IV - タスク分解と並列パターン](../python/part-4.md) |
+| Java | [Part IV - タスク分解と並列パターン](../java/part-4.md) |
+| C# | [Part IV - タスク分解と並列パターン](../csharp/part-4.md) |
+| Scala | [Part IV - タスク分解と並列パターン](../scala/part-4.md) |
+| F# | [Part IV - タスク分解と並列パターン](../fsharp/part-4.md) |
+| Rust | [Part IV - タスク分解と並列パターン](../rust/part-4.md) |
+| Haskell | [Part IV - タスク分解と並列パターン](../haskell/part-4.md) |
+| Clojure | [Part IV - タスク分解と並列パターン](../clojure/part-4.md) |