@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/getting-start-tdd/node/09-solid-principles-and-module-design.md

@@ -0,0 +1,285 @@
+# 第 9 章: SOLID 原則とモジュール設計
+
+## 9.1 はじめに
+
+前章までに多くのデザインパターンを適用しましたが、すべてのクラスが 1 つのファイルに詰め込まれた状態です。この章では **SOLID 原則** の観点からコードを検証し、責務に基づいた **モジュール設計** を行います。
+
+## 9.2 SOLID 原則の検証
+
+### 単一責任原則（SRP: Single Responsibility Principle）
+
+> クラスが変更される理由は一つでなければならない
+
+| クラス | 責務 | 変更理由 |
+|--------|------|---------|
+| `FizzBuzzValue` | FizzBuzz の結果値を表現 | 値の表現方法が変わるとき |
+| `FizzBuzzList` | FizzBuzz の結果コレクションを管理 | コレクション操作が変わるとき |
+| `FizzBuzzType01` | タイプ 1 の変換ルール | タイプ 1 のルールが変わるとき |
+| `FizzBuzzType02` | タイプ 2 の変換ルール | タイプ 2 のルールが変わるとき |
+| `FizzBuzzType03` | タイプ 3 の変換ルール | タイプ 3 のルールが変わるとき |
+| `FizzBuzzValueCommand` | 単一値の生成操作 | 値の生成方法が変わるとき |
+| `FizzBuzzListCommand` | リストの生成操作 | リストの生成方法が変わるとき |
+
+各クラスが 1 つの責務を持ち、変更理由は 1 つです。SRP を満たしています。
+
+### 開放閉鎖原則（OCP: Open-Closed Principle）
+
+> ソフトウェアエンティティは拡張に対して開いていて、修正に対して閉じている
+
+新しいタイプ（例: タイプ 4）を追加する場合:
+
+1. `FizzBuzzType04` クラスを **新規作成** する
+2. `FizzBuzzType.create()` の switch 文に 1 行 **追加** する
+
+既存の `FizzBuzzType01`〜`03` は一切変更しません。OCP を満たしています。
+
+### 依存関係逆転の原則（DIP: Dependency Inversion Principle）
+
+> 上位レベルのモジュールは下位レベルのモジュールに依存してはならない。両方とも抽象に依存すべき
+
+```
+FizzBuzzValueCommand ──→ FizzBuzzType (抽象)
+FizzBuzzListCommand  ──→ FizzBuzzType (抽象)
+                              ↑
+                    FizzBuzzType01, Type02, Type03
+```
+
+- コマンド（上位）は抽象クラス `FizzBuzzType` に依存
+- 具体的な Type01〜03 には直接依存しない
+- DIP を満たしています
+
+## 9.3 モジュール設計
+
+### 設計方針
+
+責務に基づいて 3 つのレイヤーに分割します。
+
+| レイヤー | 配置先 | 責務 |
+|---------|-------|------|
+| **ドメインモデル** | `domain/model/` | 値オブジェクト、コレクション |
+| **ドメインタイプ** | `domain/type/` | ビジネスルール（FizzBuzz 変換） |
+| **アプリケーション** | `application/` | 操作の実行（コマンド） |
+
+### ディレクトリ構成
+
+```
+src/
+├── index.ts                          (エントリポイント)
+└── fizzbuzz/
+    ├── index.ts                      (バレルファイル: 全クラスを re-export)
+    ├── domain/
+    │   ├── model/
+    │   │   ├── fizz-buzz-value.ts    (FizzBuzzValue)
+    │   │   └── fizz-buzz-list.ts     (FizzBuzzList)
+    │   └── type/
+    │       ├── fizz-buzz-type.ts     (FizzBuzzType abstract + create)
+    │       ├── fizz-buzz-type-01.ts  (FizzBuzzType01)
+    │       ├── fizz-buzz-type-02.ts  (FizzBuzzType02)
+    │       └── fizz-buzz-type-03.ts  (FizzBuzzType03)
+    └── application/
+        ├── fizz-buzz-command.ts      (FizzBuzzCommand interface)
+        ├── fizz-buzz-value-command.ts (FizzBuzzValueCommand)
+        └── fizz-buzz-list-command.ts  (FizzBuzzListCommand)
+```
+
+### 依存関係
+
+```
+application/ ──→ domain/type/ ──→ domain/model/
+     ↓                ↓                 ↓
+  コマンド          タイプ            値・コレクション
+```
+
+- `domain/model/` は他のモジュールに依存しない（最も安定）
+- `domain/type/` は `domain/model/` のみに依存
+- `application/` は `domain/type/` と `domain/model/` に依存
+
+### バレルファイル（index.ts）
+
+TypeScript では **バレルファイル** を使って、モジュールの公開 API を集約します。
+
+```typescript
+// src/fizzbuzz/index.ts
+export { FizzBuzzValue } from "./domain/model/fizz-buzz-value.js";
+export { FizzBuzzList } from "./domain/model/fizz-buzz-list.js";
+export { FizzBuzzType } from "./domain/type/fizz-buzz-type.js";
+export { FizzBuzzType01 } from "./domain/type/fizz-buzz-type-01.js";
+export { FizzBuzzType02 } from "./domain/type/fizz-buzz-type-02.js";
+export { FizzBuzzType03 } from "./domain/type/fizz-buzz-type-03.js";
+export type { FizzBuzzCommand } from "./application/fizz-buzz-command.js";
+export { FizzBuzzValueCommand } from "./application/fizz-buzz-value-command.js";
+export { FizzBuzzListCommand } from "./application/fizz-buzz-list-command.js";
+```
+
+利用側は 1 つの import パスですべてのクラスにアクセスできます:
+
+```typescript
+import {
+  FizzBuzzType,
+  FizzBuzzValueCommand,
+  FizzBuzzListCommand,
+} from "./fizzbuzz/index";
+```
+
+## 9.4 エントリポイントの更新
+
+```typescript
+// src/index.ts
+export {
+  FizzBuzzValue,
+  FizzBuzzList,
+  FizzBuzzType,
+  FizzBuzzType01,
+  FizzBuzzType02,
+  FizzBuzzType03,
+  FizzBuzzValueCommand,
+  FizzBuzzListCommand,
+} from "./fizzbuzz/index.js";
+```
+
+## 9.5 テストの再編成
+
+テストもモジュール構造に合わせて分割します。
+
+```
+test/
+└── fizzbuzz/
+    ├── domain/
+    │   ├── model/
+    │   │   ├── fizz-buzz-value.test.ts
+    │   │   └── fizz-buzz-list.test.ts
+    │   └── type/
+    │       └── fizz-buzz-type.test.ts
+    └── application/
+        └── fizz-buzz-command.test.ts
+```
+
+### fizz-buzz-type.test.ts
+
+```typescript
+import { describe, expect, test } from "vitest";
+import {
+  FizzBuzzType,
+  FizzBuzzType01,
+  FizzBuzzType02,
+  FizzBuzzType03,
+} from "../../../../src/fizzbuzz/index";
+
+describe("FizzBuzzType", () => {
+  describe("タイプ1の場合", () => {
+    const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
+
+    test("1を渡したら文字列1を返す", () => {
+      expect(type.generate(1).toString()).toBe("1");
+    });
+
+    test("3を渡したらFizzを返す", () => {
+      expect(type.generate(3).toString()).toBe("Fizz");
+    });
+
+    test("5を渡したらBuzzを返す", () => {
+      expect(type.generate(5).toString()).toBe("Buzz");
+    });
+
+    test("15を渡したらFizzBuzzを返す", () => {
+      expect(type.generate(15).toString()).toBe("FizzBuzz");
+    });
+  });
+
+  describe("ファクトリメソッド", () => {
+    test("TYPE_01 を指定すると FizzBuzzType01 が返る", () => {
+      expect(FizzBuzzType.create(FizzBuzzType.TYPE_01)).toBeInstanceOf(
+        FizzBuzzType01,
+      );
+    });
+
+    test("未定義のタイプを指定するとエラーが発生する", () => {
+      expect(() => FizzBuzzType.create(99)).toThrow("未定義のタイプ: 99");
+    });
+  });
+});
+```
+
+### fizz-buzz-command.test.ts
+
+```typescript
+import { describe, expect, test } from "vitest";
+import {
+  FizzBuzzListCommand,
+  FizzBuzzType,
+  FizzBuzzValueCommand,
+} from "../../../src/fizzbuzz/index";
+
+describe("FizzBuzzCommand", () => {
+  test("FizzBuzzValueCommand は単一の値を生成する", () => {
+    const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
+    const command = new FizzBuzzValueCommand(type, 3);
+    const result = command.execute();
+    expect(result.toString()).toBe("Fizz");
+  });
+
+  test("FizzBuzzListCommand はリストを生成する", () => {
+    const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
+    const command = new FizzBuzzListCommand(type, 100);
+    const result = command.execute();
+    expect(result.size).toBe(100);
+  });
+});
+```
+
+### テスト実行結果
+
+```
+ ✓ test/fizzbuzz/domain/model/fizz-buzz-value.test.ts (4 tests) 2ms
+ ✓ test/fizzbuzz/domain/model/fizz-buzz-list.test.ts (4 tests) 2ms
+ ✓ test/fizzbuzz/domain/type/fizz-buzz-type.test.ts (16 tests) 1ms
+ ✓ test/fizzbuzz/application/fizz-buzz-command.test.ts (3 tests) 2ms
+
+ Test Files  4 passed (4)
+      Tests  27 passed (27)
+```
+
+## 9.6 各言語のモジュール設計比較
+
+| 概念 | TypeScript | Java | Python |
+|------|-----------|------|--------|
+| モジュール単位 | ファイル（ES Modules） | パッケージ | パッケージ |
+| 公開制御 | `export` / non-export | `public` / package-private | `__all__` / `_` 規約 |
+| バレルファイル | `index.ts` の re-export | パッケージの public class | `__init__.py` |
+| 名前空間 | ファイルパス | パッケージ名 | モジュールパス |
+| 循環依存対策 | バレルファイルで集約 | パッケージ設計で制御 | `__init__.py` で制御 |
+
+## 9.7 まとめ
+
+第 3 部（章 7〜9）を通じて、手続き的な FizzBuzz を OOP 設計に進化させました。
+
+| 章 | テーマ | 適用したパターン |
+|---|--------|---------------|
+| 7 | カプセル化とポリモーフィズム | Strategy パターン、ファクトリメソッド |
+| 8 | デザインパターンの適用 | Value Object、First-Class Collection、Command パターン |
+| 9 | SOLID 原則とモジュール設計 | SRP、OCP、DIP、モジュール分割 |
+
+### Before / After
+
+**Before**（第 2 部終了時）:
+
+```
+src/fizzbuzz.ts (1 ファイル、1 クラス)
+test/fizzbuzz.test.ts (1 ファイル)
+```
+
+**After**（第 3 部終了時）:
+
+```
+src/fizzbuzz/
+├── domain/model/    (値オブジェクト、コレクション)
+├── domain/type/     (ビジネスルール)
+└── application/     (コマンド)
+
+test/fizzbuzz/
+├── domain/model/    (値・コレクションのテスト)
+├── domain/type/     (タイプのテスト)
+└── application/     (コマンドのテスト)
+```
+
+次の第 4 部では、関数型プログラミングの観点から FizzBuzz を再構成し、高階関数、不変データ、型安全なエラーハンドリングを学びます。

package/lib/assets/docs/article/getting-start-tdd/node/10-higher-order-functions-and-composition.md

@@ -0,0 +1,199 @@
+# 第 10 章: 高階関数と関数合成
+
+## 10.1 はじめに
+
+第 3 部ではオブジェクト指向設計でコードを構造化しました。第 4 部では **関数型プログラミング** の観点から FizzBuzz を再構成し、JavaScript/TypeScript の関数型機能を学びます。
+
+この章では、**高階関数**（Higher-Order Functions）と **関数合成**（Function Composition）を使って、コレクション操作をより宣言的に記述します。
+
+## 10.2 アロー関数と高階関数
+
+### アロー関数
+
+TypeScript/JavaScript のアロー関数は、関数型プログラミングの基本です。
+
+```typescript
+// 従来の関数
+function double(n: number): number {
+  return n * 2;
+}
+
+// アロー関数
+const double = (n: number): number => n * 2;
+```
+
+### 高階関数とは
+
+**高階関数** とは、関数を引数に取るか、関数を返す関数です。JavaScript の配列メソッド `map`、`filter`、`reduce` は代表的な高階関数です。
+
+## 10.3 FizzBuzzList への関数型メソッドの追加
+
+### map: 各要素を変換
+
+```typescript
+map(fn: (value: FizzBuzzValue) => FizzBuzzValue): FizzBuzzList {
+  return new FizzBuzzList(this._list.map(fn));
+}
+```
+
+**特徴**: 元のリストを変更せず、新しいリストを返します（不変性）。
+
+### filter: 条件に合う要素のみ抽出
+
+```typescript
+filter(predicate: (value: FizzBuzzValue) => boolean): FizzBuzzList {
+  return new FizzBuzzList(this._list.filter(predicate));
+}
+```
+
+### reduce: 畳み込み
+
+```typescript
+reduce<T>(fn: (acc: T, value: FizzBuzzValue) => T, initial: T): T {
+  return this._list.reduce(fn, initial);
+}
+```
+
+### テスト
+
+```typescript
+describe("関数型メソッド", () => {
+  const baseList = new FizzBuzzList([
+    new FizzBuzzValue("1", 1),
+    new FizzBuzzValue("Fizz", 3),
+    new FizzBuzzValue("Buzz", 5),
+    new FizzBuzzValue("FizzBuzz", 15),
+  ]);
+
+  test("map で値を変換する", () => {
+    const mapped = baseList.map(
+      (v) => new FizzBuzzValue(v.toString().toUpperCase(), v.number),
+    );
+    expect(mapped.toStringArray()).toEqual(["1", "FIZZ", "BUZZ", "FIZZBUZZ"]);
+    // 元のリストは変更されない
+    expect(baseList.toStringArray()).toEqual(["1", "Fizz", "Buzz", "FizzBuzz"]);
+  });
+
+  test("filter で Fizz のみ抽出できる", () => {
+    const filtered = baseList.filter((v) => v.value === "Fizz");
+    expect(filtered.toStringArray()).toEqual(["Fizz"]);
+  });
+
+  test("reduce で文字列結合できる", () => {
+    const reduced = baseList.reduce(
+      (acc, v) => `${acc}${acc.length > 0 ? "," : ""}${v.toString()}`,
+      "",
+    );
+    expect(reduced).toBe("1,Fizz,Buzz,FizzBuzz");
+  });
+});
+```
+
+## 10.4 FizzBuzzListCommand の関数的リファクタリング
+
+### Before: for ループ
+
+```typescript
+execute(): FizzBuzzList {
+  let list = new FizzBuzzList();
+  for (let i = 1; i <= this._count; i++) {
+    list = list.add(this._type.generate(i));
+  }
+  return list;
+}
+```
+
+### After: Array.from + reduce
+
+```typescript
+execute(): FizzBuzzList {
+  return Array.from({ length: this._count }, (_, i) => i + 1).reduce(
+    (list, num) => list.add(this._type.generate(num)),
+    new FizzBuzzList(),
+  );
+}
+```
+
+**変更点**:
+
+- `for` ループを `Array.from` + `reduce` に置き換え
+- 宣言的な記述に変更（「何を」するかが明確）
+- 既存のテストはすべてそのまま通過
+
+## 10.5 関数合成ユーティリティ
+
+### compose と pipe
+
+```typescript
+// compose: 右から左に合成 f(g(x))
+export const compose =
+  <T>(...fns: ((arg: T) => T)[]): ((arg: T) => T) =>
+  (arg: T) =>
+    fns.reduceRight((acc, fn) => fn(acc), arg);
+
+// pipe: 左から右に合成 g(f(x))
+export const pipe =
+  <T>(...fns: ((arg: T) => T)[]): ((arg: T) => T) =>
+  (arg: T) =>
+    fns.reduce((acc, fn) => fn(acc), arg);
+```
+
+### フィルタ述語関数
+
+カリー化されたフィルタ関数で、再利用可能な述語を定義します。
+
+```typescript
+export const isFizz = (v: FizzBuzzValue): boolean => v.value === "Fizz";
+export const isBuzz = (v: FizzBuzzValue): boolean => v.value === "Buzz";
+export const isFizzBuzz = (v: FizzBuzzValue): boolean => v.value === "FizzBuzz";
+export const isNumber = (v: FizzBuzzValue): boolean => !isNaN(Number(v.value));
+```
+
+### テスト
+
+```typescript
+describe("関数合成", () => {
+  test("compose は右から左に適用する", () => {
+    const double = (n: number): number => n * 2;
+    const increment = (n: number): number => n + 1;
+    const fn = compose(double, increment);
+    expect(fn(3)).toBe(8); // double(increment(3)) = double(4) = 8
+  });
+
+  test("pipe は左から右に適用する", () => {
+    const double = (n: number): number => n * 2;
+    const increment = (n: number): number => n + 1;
+    const fn = pipe(double, increment);
+    expect(fn(3)).toBe(7); // increment(double(3)) = increment(6) = 7
+  });
+});
+
+describe("フィルタ関数", () => {
+  test("isFizz は Fizz のとき true を返す", () => {
+    expect(isFizz(new FizzBuzzValue("Fizz", 3))).toBe(true);
+    expect(isFizz(new FizzBuzzValue("Buzz", 5))).toBe(false);
+  });
+});
+```
+
+## 10.6 各言語の高階関数比較
+
+| 概念 | TypeScript | Java | Python |
+|------|-----------|------|--------|
+| ラムダ式 | `(x) => x * 2` | `x -> x * 2` | `lambda x: x * 2` |
+| map | `array.map(fn)` | `stream.map(fn)` | `map(fn, list)` / 内包表記 |
+| filter | `array.filter(fn)` | `stream.filter(fn)` | `filter(fn, list)` / 内包表記 |
+| reduce | `array.reduce(fn, init)` | `stream.reduce(init, fn)` | `functools.reduce(fn, list, init)` |
+| 関数合成 | `compose(f, g)` / `pipe(f, g)` | `f.andThen(g)` / `f.compose(g)` | `functools.reduce` で実装 |
+| 述語関数 | `const isFizz = (v) => ...` | `Predicate<T>` インターフェース | `def is_fizz(v): ...` |
+
+## 10.7 まとめ
+
+この章で学んだこと:
+
+1. **アロー関数**: 簡潔な関数リテラルで高階関数を活用
+2. **map/filter/reduce**: コレクションの宣言的操作
+3. **関数合成**: `compose`（右→左）と `pipe`（左→右）で関数を組み合わせ
+4. **述語関数**: 再利用可能なフィルタ条件を関数として定義
+
+次の章では、不変データの原則をさらに深め、パイプライン処理でデータを変換するパターンを学びます。

package/lib/assets/docs/article/getting-start-tdd/node/11-immutable-data-and-pipeline.md

@@ -0,0 +1,207 @@
+# 第 11 章: 不変データとパイプライン処理
+
+## 11.1 はじめに
+
+前章では高階関数と関数合成を学びました。この章では **不変データ** の原則をさらに深め、**パイプライン処理** でデータを流れるように変換するパターンを学びます。
+
+## 11.2 不変データの原則
+
+### 既存の不変設計
+
+第 3 部で実装した FizzBuzzList は既に不変性を備えています。
+
+| メカニズム | 実装方法 |
+|-----------|---------|
+| **フィールドの凍結** | `Object.freeze([...list])` |
+| **不変な追加** | `add()` は新しいインスタンスを返す |
+| **readonly 型** | `readonly FizzBuzzValue[]` で型レベルの保護 |
+| **private フィールド** | 外部から直接変更不可 |
+
+### TypeScript の不変性サポート
+
+| 手法 | 用途 |
+|------|------|
+| `readonly` 修飾子 | プロパティの再代入を防止 |
+| `ReadonlyArray<T>` | 配列の変更メソッドを型レベルで禁止 |
+| `Object.freeze()` | 実行時にオブジェクトの変更を防止 |
+| `as const` | リテラル型の推論と readonly 化 |
+| Spread 演算子 | `{...obj}` / `[...arr]` でシャローコピー |
+
+## 11.3 パイプライン処理メソッド
+
+### groupBy: 値の種類ごとにグループ化
+
+```typescript
+groupBy(fn: (value: FizzBuzzValue) => string): Map<string, FizzBuzzList> {
+  return this._list.reduce((groups, value) => {
+    const key = fn(value);
+    const group = groups.get(key) ?? new FizzBuzzList();
+    groups.set(key, group.add(value));
+    return groups;
+  }, new Map<string, FizzBuzzList>());
+}
+```
+
+### countBy: 種類ごとの出現回数をカウント
+
+```typescript
+countBy(fn: (value: FizzBuzzValue) => string): Map<string, number> {
+  return this._list.reduce((counts, value) => {
+    const key = fn(value);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+    return counts;
+  }, new Map<string, number>());
+}
+```
+
+### take / first / join
+
+```typescript
+take(n: number): FizzBuzzList {
+  return new FizzBuzzList(this._list.slice(0, Math.max(0, n)));
+}
+
+first(): FizzBuzzValue | undefined {
+  return this._list[0];
+}
+
+join(separator: string): string {
+  return this._list.map((value) => value.toString()).join(separator);
+}
+```
+
+## 11.4 ジェネレータベースの生成
+
+### ジェネレータ関数
+
+TypeScript の `function*` でジェネレータを定義し、遅延評価でシーケンスを生成します。
+
+```typescript
+private static *sequence(
+  type: FizzBuzzGenerator,
+  count: number,
+): Generator<FizzBuzzValue> {
+  for (let number = 1; number <= count; number += 1) {
+    yield type.generate(number);
+  }
+}
+
+static generate(type: FizzBuzzGenerator, count: number): FizzBuzzList {
+  return new FizzBuzzList([...FizzBuzzList.sequence(type, count)]);
+}
+```
+
+### 循環参照の回避
+
+`FizzBuzzType` を直接 import すると循環参照が発生するため、構造的型付けで回避します。
+
+```typescript
+type FizzBuzzGenerator = {
+  generate(number: number): FizzBuzzValue;
+};
+```
+
+TypeScript のダックタイピングにより、`FizzBuzzType` のインスタンスは `FizzBuzzGenerator` 型を自動的に満たします。
+
+## 11.5 テスト
+
+### パイプライン処理テスト
+
+```typescript
+describe("パイプライン処理", () => {
+  const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
+  const list = FizzBuzzList.generate(type, 15);
+
+  test("groupBy で値の種類ごとにグループ化する", () => {
+    const groups = list.groupBy((v) => {
+      if (v.value === "FizzBuzz") return "FizzBuzz";
+      if (v.value === "Fizz") return "Fizz";
+      if (v.value === "Buzz") return "Buzz";
+      return "number";
+    });
+    expect(groups.get("Fizz")?.size).toBe(4);
+    expect(groups.get("Buzz")?.size).toBe(2);
+    expect(groups.get("FizzBuzz")?.size).toBe(1);
+    expect(groups.get("number")?.size).toBe(8);
+  });
+
+  test("countBy で種類ごとの出現回数をカウントする", () => {
+    const counts = list.countBy((v) => {
+      if (v.value === "FizzBuzz") return "FizzBuzz";
+      if (v.value === "Fizz") return "Fizz";
+      if (v.value === "Buzz") return "Buzz";
+      return "number";
+    });
+    expect(counts.get("Fizz")).toBe(4);
+    expect(counts.get("FizzBuzz")).toBe(1);
+  });
+
+  test("take で先頭N件を取得する", () => {
+    expect(list.take(3).toStringArray()).toEqual(["1", "2", "Fizz"]);
+  });
+
+  test("first で最初の要素を取得する", () => {
+    expect(list.first()?.toString()).toBe("1");
+  });
+
+  test("join で文字列結合する", () => {
+    expect(list.take(5).join(", ")).toBe("1, 2, Fizz, 4, Buzz");
+  });
+
+  test("メソッドチェーンでパイプライン処理する", () => {
+    const result = list
+      .filter((v) => v.value === "Fizz")
+      .take(2)
+      .join(", ");
+    expect(result).toBe("Fizz, Fizz");
+  });
+});
+```
+
+### 静的生成メソッドテスト
+
+```typescript
+describe("静的生成メソッド", () => {
+  test("generate でリストを生成する", () => {
+    const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
+    const list = FizzBuzzList.generate(type, 15);
+    expect(list.size).toBe(15);
+    expect(list.first()?.toString()).toBe("1");
+  });
+});
+```
+
+### テスト実行結果
+
+```
+ ✓ test/fizzbuzz/domain/model/fizz-buzz-list.test.ts (15 tests) 10ms
+ ✓ test/fizzbuzz/domain/model/fizz-buzz-value.test.ts (4 tests) 3ms
+ ✓ test/fizzbuzz/domain/type/fizz-buzz-type.test.ts (16 tests) 7ms
+ ✓ test/fizzbuzz/domain/type/fizz-buzz-util.test.ts (6 tests) 4ms
+ ✓ test/fizzbuzz/application/fizz-buzz-command.test.ts (3 tests) 4ms
+
+ Test Files  5 passed (5)
+      Tests  44 passed (44)
+```
+
+## 11.6 各言語のパイプライン比較
+
+| 概念 | TypeScript | Java | Python |
+|------|-----------|------|--------|
+| パイプライン | メソッドチェーン | Stream API | ジェネレータ + itertools |
+| グループ化 | `Map` + `reduce` | `Collectors.groupingBy()` | `dict` + ループ |
+| 遅延評価 | `function*` ジェネレータ | `Stream` の中間操作 | `yield` ジェネレータ |
+| 不変コピー | Spread `[...arr]` | `Collections.unmodifiableList()` | `tuple` / `frozenset` |
+| 結合 | `array.join()` | `Collectors.joining()` | `str.join()` |
+
+## 11.7 まとめ
+
+この章で学んだこと:
+
+1. **不変データ**: `Object.freeze()`、`readonly`、Spread 演算子で不変性を保証
+2. **パイプライン処理**: `groupBy`、`countBy`、`take`、`first`、`join` でデータを流れるように変換
+3. **メソッドチェーン**: `.filter().take().join()` の連鎖で宣言的なデータ処理
+4. **ジェネレータ**: `function*` と `yield` による遅延評価シーケンス
+5. **構造的型付け**: 循環参照を避けるダックタイピング
+
+次の章では、エラーハンドリングと型安全性の観点から、TypeScript の型システムを活用したより安全なコードを学びます。