@k2works/claude-code-booster 3.0.0 → 3.1.0

package/lib/assets/docs/article/getting-start-tdd/index.md

@@ -0,0 +1,93 @@
+# テスト駆動開発から始めるXX入門
+
+本記事シリーズは、テスト駆動開発（TDD）の手法を用いて、様々なプログラミング言語の特徴を実践的に学ぶためのガイドです。
+
+FizzBuzz 問題を共通題材に、14 の言語で同じ TDD サイクル（Red-Green-Refactor）を体験し、言語ごとの設計思想と共通する本質を探求します。
+
+## 言語別解説
+
+| 言語 | 環境 | 特徴 |
+|------|------|------|
+| [Java](java/index.md) | JVM | 静的型付け、オブジェクト指向、豊富なエコシステム |
+| [JavaScript](node/index.md) | Node.js | 動的型付け、プロトタイプベース、非同期処理 |
+| [TypeScript](node/index.md) | Node.js | JavaScript + 静的型付け、型推論、インターフェース |
+| [Python](python/index.md) | CPython | 動的型付け、読みやすさ重視、マルチパラダイム |
+| [Ruby](ruby/index.md) | CRuby | 動的型付け、すべてがオブジェクト、DSL 親和性 |
+| [PHP](php/index.md) | PHP | 動的型付け、Web 特化、漸進的型付け対応 |
+| [Go](go/index.md) | Go | 静的型付け、ゴルーチン、シンプルな言語仕様 |
+| [Rust](rust/index.md) | Rust | 所有権システム、ゼロコスト抽象化、メモリ安全性 |
+| [C#](csharp/index.md) | .NET | 静的型付け、OOP + FP ハイブリッド、LINQ |
+| [F#](fsharp/index.md) | .NET | 関数型ファースト、判別共用体、パイプライン |
+| [Clojure](clojure/index.md) | JVM | LISP 方言、動的型付け、不変データ構造 |
+| [Scala](scala/index.md) | JVM | OOP と FP の融合、強力な型システム、パターンマッチング |
+| [Elixir](elixir/index.md) | Erlang VM | 関数型、並行処理、パターンマッチング、OTP |
+| [Haskell](haskell/index.md) | GHC | 純粋関数型、型クラス、モナド、遅延評価 |
+
+## 多言語統合解説
+
+[多言語統合解説](integration/index.md) では、14 言語の実装を横断的に比較し、TDD の本質と言語固有の表現を統合的に解説します。
+
+## 章構成
+
+### 第 1 部: TDD の基本サイクル
+
+| 章 | テーマ | Java | JS/TS | Python | Ruby | PHP | Go | Rust | C# | F# | Clojure | Scala | Elixir | Haskell |
+|----|--------|------|-------|--------|------|-----|-----|------|-----|-----|---------|-------|--------|---------|
+| 1 | TODO リストと最初のテスト | [Java](java/01-todo-list-and-first-test.md) | [JS/TS](node/01-todo-list-and-first-test.md) | [Python](python/01-todo-list-and-first-test.md) | [Ruby](ruby/01-todo-list-and-first-test.md) | [PHP](php/01-todo-list-and-first-test.md) | [Go](go/01-todo-list-and-first-test.md) | [Rust](rust/01-todo-list-and-first-test.md) | [C#](csharp/chapter01.md) | [F#](fsharp/chapter01.md) | [Clojure](clojure/01-todo-list-and-first-test.md) | [Scala](scala/01-todo-list-and-first-test.md) | [Elixir](elixir/01-todo-list-and-first-test.md) | [Haskell](haskell/01-todo-list-and-first-test.md) |
+| 2 | 仮実装と三角測量 | [Java](java/02-fake-it-and-triangulation.md) | [JS/TS](node/02-fake-it-and-triangulation.md) | [Python](python/02-fake-it-and-triangulation.md) | [Ruby](ruby/02-fake-it-and-triangulation.md) | [PHP](php/02-fake-it-and-triangulation.md) | [Go](go/02-fake-it-and-triangulation.md) | [Rust](rust/02-fake-it-and-triangulation.md) | [C#](csharp/chapter02.md) | [F#](fsharp/chapter02.md) | [Clojure](clojure/02-fake-it-and-triangulation.md) | [Scala](scala/02-fake-it-and-triangulation.md) | [Elixir](elixir/02-fake-it-and-triangulation.md) | [Haskell](haskell/02-fake-it-and-triangulation.md) |
+| 3 | 明白な実装とリファクタリング | [Java](java/03-obvious-implementation-and-refactoring.md) | [JS/TS](node/03-obvious-implementation-and-refactoring.md) | [Python](python/03-obvious-implementation-and-refactoring.md) | [Ruby](ruby/03-obvious-implementation-and-refactoring.md) | [PHP](php/03-obvious-implementation-and-refactoring.md) | [Go](go/03-obvious-implementation-and-refactoring.md) | [Rust](rust/03-obvious-implementation-and-refactoring.md) | [C#](csharp/chapter03.md) | [F#](fsharp/chapter03.md) | [Clojure](clojure/03-obvious-implementation-and-refactoring.md) | [Scala](scala/03-obvious-implementation-and-refactoring.md) | [Elixir](elixir/03-obvious-implementation-and-refactoring.md) | [Haskell](haskell/03-obvious-implementation-and-refactoring.md) |
+
+### 第 2 部: 開発環境と自動化
+
+| 章 | テーマ | Java | JS/TS | Python | Ruby | PHP | Go | Rust | C# | F# | Clojure | Scala | Elixir | Haskell |
+|----|--------|------|-------|--------|------|-----|-----|------|-----|-----|---------|-------|--------|---------|
+| 4 | バージョン管理と Conventional Commits | [Java](java/04-version-control-and-conventional-commits.md) | [JS/TS](node/04-version-control-and-conventional-commits.md) | [Python](python/04-version-control-and-conventional-commits.md) | [Ruby](ruby/04-version-control-and-conventional-commits.md) | [PHP](php/04-version-control-and-conventional-commits.md) | [Go](go/04-version-control-and-conventional-commits.md) | [Rust](rust/04-version-control-and-conventional-commits.md) | [C#](csharp/chapter04.md) | [F#](fsharp/chapter04.md) | [Clojure](clojure/04-version-control-and-conventional-commits.md) | [Scala](scala/04-version-control-and-conventional-commits.md) | [Elixir](elixir/04-version-control-and-conventional-commits.md) | [Haskell](haskell/04-version-control-and-conventional-commits.md) |
+| 5 | パッケージ管理と静的解析 | [Java](java/05-package-management-and-static-analysis.md) | [JS/TS](node/05-package-management-and-static-analysis.md) | [Python](python/05-package-management-and-static-analysis.md) | [Ruby](ruby/05-package-management-and-static-analysis.md) | [PHP](php/05-package-management-and-static-analysis.md) | [Go](go/05-package-management-and-static-analysis.md) | [Rust](rust/05-package-management-and-static-analysis.md) | [C#](csharp/chapter05.md) | [F#](fsharp/chapter05.md) | [Clojure](clojure/05-package-management-and-static-analysis.md) | [Scala](scala/05-package-management-and-static-analysis.md) | [Elixir](elixir/05-package-management-and-static-analysis.md) | [Haskell](haskell/05-package-management-and-static-analysis.md) |
+| 6 | タスクランナーと CI/CD | [Java](java/06-task-runner-and-ci-cd.md) | [JS/TS](node/06-task-runner-and-ci-cd.md) | [Python](python/06-task-runner-and-ci-cd.md) | [Ruby](ruby/06-task-runner-and-ci-cd.md) | [PHP](php/06-task-runner-and-ci-cd.md) | [Go](go/06-task-runner-and-ci-cd.md) | [Rust](rust/06-task-runner-and-ci-cd.md) | [C#](csharp/chapter06.md) | [F#](fsharp/chapter06.md) | [Clojure](clojure/06-task-runner-and-ci-cd.md) | [Scala](scala/06-task-runner-and-ci-cd.md) | [Elixir](elixir/06-task-runner-and-ci-cd.md) | [Haskell](haskell/06-task-runner-and-ci-cd.md) |
+
+### 第 3 部: オブジェクト指向設計
+
+| 章 | テーマ | Java | JS/TS | Python | Ruby | PHP | Go | Rust | C# | F# | Clojure | Scala | Elixir | Haskell |
+|----|--------|------|-------|--------|------|-----|-----|------|-----|-----|---------|-------|--------|---------|
+| 7 | カプセル化とポリモーフィズム | [Java](java/07-encapsulation-and-polymorphism.md) | [JS/TS](node/07-encapsulation-and-polymorphism.md) | [Python](python/07-encapsulation-and-polymorphism.md) | [Ruby](ruby/07-encapsulation-and-polymorphism.md) | [PHP](php/07-encapsulation-and-polymorphism.md) | [Go](go/07-encapsulation-and-polymorphism.md) | [Rust](rust/07-encapsulation-and-polymorphism.md) | [C#](csharp/chapter07.md) | [F#](fsharp/chapter07.md) | [Clojure](clojure/07-protocols-and-records.md) | [Scala](scala/07-case-classes-and-traits.md) | [Elixir](elixir/07-structs-and-protocols.md) | [Haskell](haskell/07-algebraic-data-types-and-type-classes.md) |
+| 8 | デザインパターンの適用 | [Java](java/08-design-patterns.md) | [JS/TS](node/08-design-patterns.md) | [Python](python/08-design-patterns.md) | [Ruby](ruby/08-design-patterns.md) | [PHP](php/08-design-patterns.md) | [Go](go/08-design-patterns.md) | [Rust](rust/08-design-patterns.md) | [C#](csharp/chapter08.md) | [F#](fsharp/chapter08.md) | [Clojure](clojure/08-multimethods-and-design-patterns.md) | [Scala](scala/08-pattern-matching-and-sealed-traits.md) | [Elixir](elixir/08-pattern-matching-and-guards.md) | [Haskell](haskell/08-pattern-matching-and-guards.md) |
+| 9 | SOLID 原則とモジュール設計 | [Java](java/09-solid-principles-and-module-design.md) | [JS/TS](node/09-solid-principles-and-module-design.md) | [Python](python/09-solid-principles-and-module-design.md) | [Ruby](ruby/09-solid-principles-and-module-design.md) | [PHP](php/09-solid-principles-and-module-design.md) | [Go](go/09-solid-principles-and-module-design.md) | [Rust](rust/09-solid-principles-and-module-design.md) | [C#](csharp/chapter09.md) | [F#](fsharp/chapter09.md) | [Clojure](clojure/09-namespaces-and-module-design.md) | [Scala](scala/09-packages-and-module-design.md) | [Elixir](elixir/09-module-design-and-behaviours.md) | [Haskell](haskell/09-module-design-and-smart-constructors.md) |
+
+### 第 4 部: 関数型プログラミングへの展開
+
+| 章 | テーマ | Java | JS/TS | Python | Ruby | PHP | Go | Rust | C# | F# | Clojure | Scala | Elixir | Haskell |
+|----|--------|------|-------|--------|------|-----|-----|------|-----|-----|---------|-------|--------|---------|
+| 10 | 高階関数と関数合成 | [Java](java/10-higher-order-functions-and-composition.md) | [JS/TS](node/10-higher-order-functions-and-composition.md) | [Python](python/10-higher-order-functions-and-composition.md) | [Ruby](ruby/10-higher-order-functions-and-composition.md) | [PHP](php/10-higher-order-functions-and-composition.md) | [Go](go/10-higher-order-functions-and-composition.md) | [Rust](rust/10-higher-order-functions-and-composition.md) | [C#](csharp/chapter10.md) | [F#](fsharp/chapter10.md) | [Clojure](clojure/10-higher-order-functions-and-composition.md) | [Scala](scala/10-higher-order-functions-and-composition.md) | [Elixir](elixir/10-higher-order-functions-and-pipeline.md) | [Haskell](haskell/10-higher-order-functions-and-currying.md) |
+| 11 | 不変データとパイプライン処理 | [Java](java/11-immutable-data-and-pipeline.md) | [JS/TS](node/11-immutable-data-and-pipeline.md) | [Python](python/11-immutable-data-and-pipeline.md) | [Ruby](ruby/11-immutable-data-and-pipeline.md) | [PHP](php/11-immutable-data-and-pipeline.md) | [Go](go/11-immutable-data-and-pipeline.md) | [Rust](rust/11-immutable-data-and-pipeline.md) | [C#](csharp/chapter11.md) | [F#](fsharp/chapter11.md) | [Clojure](clojure/11-persistent-data-and-pipeline.md) | [Scala](scala/11-collections-and-lazy-evaluation.md) | [Elixir](elixir/11-stream-and-lazy-evaluation.md) | [Haskell](haskell/11-function-composition-and-point-free.md) |
+| 12 | エラーハンドリングと型安全性 | [Java](java/12-error-handling-and-type-safety.md) | [JS/TS](node/12-error-handling-and-type-safety.md) | [Python](python/12-error-handling-and-type-safety.md) | [Ruby](ruby/12-error-handling-and-type-safety.md) | [PHP](php/12-error-handling-and-type-safety.md) | [Go](go/12-error-handling-and-type-safety.md) | [Rust](rust/12-error-handling-and-type-safety.md) | [C#](csharp/chapter12.md) | [F#](fsharp/chapter12.md) | [Clojure](clojure/12-error-handling-and-spec.md) | [Scala](scala/12-error-handling-and-type-safety.md) | [Elixir](elixir/12-error-handling-and-with.md) | [Haskell](haskell/12-monad-and-error-handling.md) |
+
+## テスト駆動開発について
+
+このシリーズでは、各プログラミング言語でテスト駆動開発の手法を用いて実装していきます。テスト駆動開発の基本的な流れは以下の通りです：
+
+1. **レッド** - まず、失敗するテストを書く
+2. **グリーン** - テストが通るように最小限のコードを実装する
+3. **リファクタリング** - コードの品質を向上させる（重複の除去、可読性の向上など）
+
+この流れを繰り返すことで、確実に動作するコードを段階的に作り上げていきます。
+
+## 対象読者
+
+- プログラミングの基本構文を理解している方
+- 複数のプログラミング言語に興味がある方
+- テスト駆動開発に興味がある方
+- 言語の特徴を理解したい方
+
+## 共通のテーマ
+
+- FizzBuzz 問題を題材にした TDD 体験
+- 各言語のテスティングフレームワーク
+- 言語固有の特徴と設計思想
+- 開発環境の構築とツールチェーン
+
+## 参照
+
+- 『テスト駆動開発』 - Kent Beck
+- 『リファクタリング』 - Martin Fowler
+- 『Clean Code』 - Robert C. Martin
+- 『エクストリームプログラミング』 - Kent Beck

package/lib/assets/docs/article/getting-start-tdd/integration/01-language-overview.md

@@ -0,0 +1,375 @@
+# 12 言語の概要と分類
+
+本章では、12 言語を複数の軸で分類し、それぞれの設計思想と特徴を俯瞰します。最後に、各言語の FizzBuzz コア実装を比較することで、同一の仕様が言語ごとにどう表現されるかを確認します。
+
+## パラダイム別分類
+
+プログラミング言語はその設計思想に基づいて、大きく以下のパラダイムに分類できます。
+
+### OOP（オブジェクト指向プログラミング）
+
+クラスとオブジェクトを中心に、カプセル化・継承・ポリモーフィズムで設計する言語です。
+
+| 言語 | 特徴 |
+|------|------|
+| Java | 静的型付け、インターフェース、豊富なエコシステム |
+| C# | .NET ランタイム、LINQ、パターンマッチング対応 |
+| PHP | Web 特化、漸進的型付け、名前空間 |
+
+### FP（関数型プログラミング）
+
+関数を第一級オブジェクトとし、不変データ・副作用の分離を重視する言語です。
+
+| 言語 | 特徴 |
+|------|------|
+| Haskell | 純粋関数型、型クラス、モナド、遅延評価 |
+| Clojure | LISP 方言、動的型付け、不変データ構造、プロトコル |
+| Elixir | BEAM VM、パターンマッチング、パイプライン、OTP |
+| F# | .NET ランタイム、判別共用体、パイプライン演算子 |
+
+### マルチパラダイム
+
+OOP と FP の両方を自然にサポートする言語です。
+
+| 言語 | OOP 要素 | FP 要素 |
+|------|---------|---------|
+| Python | クラス、継承、ABC | デコレータ、ジェネレータ、functools |
+| TypeScript | クラス、インターフェース | アロー関数、型ガード、ユニオン型 |
+| Ruby | すべてがオブジェクト | ブロック/Proc/Lambda、Enumerable |
+| Rust | trait、構造体 | パターンマッチング、イテレータ、Option/Result |
+| Scala | クラス、trait | sealed trait/case class、for 内包表記 |
+| Go | 構造体、インターフェース | ファーストクラス関数、クロージャ |
+
+## 型システムによる分類
+
+型システムは言語の安全性と表現力を大きく左右します。
+
+### 静的型付け vs 動的型付け
+
+| 分類 | 言語 | 型チェックのタイミング |
+|------|------|---------------------|
+| 静的型付け | Java, TypeScript, Go, Rust, C#, F#, Scala, Haskell | コンパイル時 |
+| 動的型付け | Python, Ruby, PHP, Clojure, Elixir | 実行時 |
+
+### 型の強さのスペクトル
+
+型の強さは「暗黙の型変換をどれだけ許容するか」で測ることができます。
+
+```
+弱い型付け ←────────────────────────────→ 強い型付け
+
+PHP  JavaScript  Python  Ruby  Java  Go  C#  F#  Scala  Rust  Haskell
+```
+
+| レベル | 言語例 | 特徴 |
+|--------|-------|------|
+| 非常に強い | Haskell, Rust | 暗黙の変換がほぼない、型推論が強力 |
+| 強い | Java, C#, F#, Scala, Go | 明示的なキャストが必要 |
+| 中程度 | Python, Ruby, TypeScript | 一部の暗黙変換を許容 |
+| 比較的柔軟 | PHP, Clojure, Elixir | 動的だが実行時にチェック |
+
+### 型推論の能力
+
+| レベル | 言語 | 例 |
+|--------|------|-----|
+| 完全推論（HM 型推論） | Haskell, F# | ほぼすべてのローカル型を推論 |
+| 高い推論能力 | Rust, Scala, TypeScript | ローカル変数・ジェネリクスの推論 |
+| 中程度 | Java, C#, Go | `var` / `:=` によるローカル推論 |
+| 限定的 | Python, Ruby, PHP | 型ヒント/アノテーションで補完 |
+| 不要 | Clojure, Elixir | 動的型付けのため型推論が不要 |
+
+## ランタイム環境による分類
+
+言語がどの実行環境上で動作するかは、パフォーマンス特性やエコシステムに影響します。
+
+### JVM（Java Virtual Machine）
+
+| 言語 | JVM 上の特徴 |
+|------|-------------|
+| Java | JVM のネイティブ言語、最大のエコシステム |
+| Scala | JVM + 独自の OOP/FP 融合 |
+| Clojure | JVM + LISP、Java ライブラリとの相互運用 |
+
+### BEAM（Erlang VM）
+
+| 言語 | BEAM 上の特徴 |
+|------|-------------|
+| Elixir | 軽量プロセス、耐障害性、ホットコードスワップ |
+
+### CLR（.NET Common Language Runtime）
+
+| 言語 | CLR 上の特徴 |
+|------|-------------|
+| C# | .NET のプライマリ言語、クロスプラットフォーム |
+| F# | .NET 上の関数型ファースト言語 |
+
+### ネイティブコンパイル
+
+| 言語 | 特徴 |
+|------|------|
+| Rust | ゼロコスト抽象化、所有権システム、メモリ安全性 |
+| Go | 高速コンパイル、静的リンク、ゴルーチン |
+| Haskell | GHC によるネイティブコンパイル、遅延評価 |
+
+### インタプリタ / JIT
+
+| 言語 | 特徴 |
+|------|------|
+| Python | CPython インタプリタ、豊富な科学計算ライブラリ |
+| Ruby | CRuby、DSL 構築に強い |
+| PHP | Zend Engine、Web に特化 |
+| TypeScript | Node.js (V8 JIT) 上で実行 |
+
+## FizzBuzz コア実装の比較
+
+同一の FizzBuzz 仕様を各言語でどう表現するかを比較します。いずれも「数値を受け取り、3 の倍数なら "Fizz"、5 の倍数なら "Buzz"、両方の倍数なら "FizzBuzz"、それ以外は数値の文字列を返す」という仕様です。
+
+### Java
+
+```java
+public abstract class FizzBuzzType {
+    protected static final int FIZZ_NUMBER = 3;
+    protected static final int BUZZ_NUMBER = 5;
+
+    public abstract FizzBuzzValue generate(int number);
+
+    protected boolean isFizz(int number) {
+        return number % FIZZ_NUMBER == 0;
+    }
+
+    protected boolean isBuzz(int number) {
+        return number % BUZZ_NUMBER == 0;
+    }
+
+    protected boolean isFizzBuzz(int number) {
+        return isFizz(number) && isBuzz(number);
+    }
+}
+```
+
+### Python
+
+```python
+class FizzBuzzType(ABC):
+    @abstractmethod
+    def generate(self, number: int) -> FizzBuzzValue:
+        pass
+
+    def _is_fizz(self, number: int) -> bool:
+        return number % 3 == 0
+
+    def _is_buzz(self, number: int) -> bool:
+        return number % 5 == 0
+
+    def _is_fizz_buzz(self, number: int) -> bool:
+        return number % 15 == 0
+```
+
+### TypeScript
+
+```typescript
+export abstract class FizzBuzzType {
+  static readonly TYPE_01 = 1;
+  static readonly TYPE_02 = 2;
+  static readonly TYPE_03 = 3;
+
+  abstract generate(number: number): FizzBuzzValue;
+
+  static create(type: number = FizzBuzzType.TYPE_01): FizzBuzzType {
+    switch (type) {
+      case FizzBuzzType.TYPE_01: return new FizzBuzzType01();
+      case FizzBuzzType.TYPE_02: return new FizzBuzzType02();
+      case FizzBuzzType.TYPE_03: return new FizzBuzzType03();
+      default: throw new Error(`未定義のタイプ: ${type}`);
+    }
+  }
+}
+```
+
+### Ruby
+
+FizzBuzzType の継承による型分け（OOP スタイル）を採用しています。
+
+```ruby
+class FizzBuzzType
+  def generate(number)
+    raise NotImplementedError
+  end
+
+  private
+
+  def fizz?(number) = (number % 3).zero?
+  def buzz?(number) = (number % 5).zero?
+  def fizz_buzz?(number) = fizz?(number) && buzz?(number)
+end
+```
+
+### Go
+
+インターフェースと構造体による構造化プログラミングスタイルです。
+
+```go
+func Generate(number int) string {
+    switch {
+    case number%15 == 0:
+        return "FizzBuzz"
+    case number%3 == 0:
+        return "Fizz"
+    case number%5 == 0:
+        return "Buzz"
+    default:
+        return strconv.Itoa(number)
+    }
+}
+```
+
+### PHP
+
+```php
+final class FizzBuzz
+{
+    public function generate(int $number): string
+    {
+        $type = new FizzBuzzType01();
+        return $type->generate($number)->getValue();
+    }
+}
+```
+
+### Rust
+
+パターンマッチングによる簡潔な表現です。
+
+```rust
+pub fn generate(number: i32) -> String {
+    match (number % 3, number % 5) {
+        (0, 0) => "FizzBuzz".to_string(),
+        (0, _) => "Fizz".to_string(),
+        (_, 0) => "Buzz".to_string(),
+        _ => number.to_string(),
+    }
+}
+```
+
+### C#
+
+Factory パターンによる型安全な生成です。
+
+```csharp
+public static class FizzBuzzRunner
+{
+    public static string Generate(int number)
+    {
+        var type = FizzBuzzTypeFactory.Create(FizzBuzzTypeName.Standard);
+        var value = type.Generate(number);
+        return value.Value;
+    }
+}
+```
+
+### F#
+
+判別共用体とパイプラインによる関数型アプローチです。
+
+```fsharp
+type FizzBuzzType =
+    | Standard
+    | NumberOnly
+    | FizzBuzzOnly
+
+let generate (fizzBuzzType: FizzBuzzType) (number: int) : FizzBuzzValue =
+    match fizzBuzzType with
+    | Standard ->
+        if isFizzBuzz number then createValue number "FizzBuzz"
+        elif isFizz number then createValue number "Fizz"
+        elif isBuzz number then createValue number "Buzz"
+        else createValue number (string number)
+    | NumberOnly -> createValue number (string number)
+    | FizzBuzzOnly ->
+        if number % 15 = 0 then createValue number "FizzBuzz"
+        else createValue number (string number)
+```
+
+### Clojure
+
+プロトコルと defrecord による多態性です。
+
+```clojure
+(defn fizzbuzz [n]
+  (cond
+    (and (zero? (mod n 3)) (zero? (mod n 5))) "FizzBuzz"
+    (zero? (mod n 3)) "Fizz"
+    (zero? (mod n 5)) "Buzz"
+    :else (str n)))
+```
+
+### Scala
+
+パターンマッチングとガード節による表現です。
+
+```scala
+object FizzBuzz:
+  def generate(number: Int): String =
+    number match
+      case n if n % 15 == 0 => "FizzBuzz"
+      case n if n % 3 == 0  => "Fizz"
+      case n if n % 5 == 0  => "Buzz"
+      case n                => n.toString
+```
+
+### Elixir
+
+パターンマッチングとガード節、パイプラインによる関数型スタイルです。
+
+```elixir
+def generate(number) when is_integer(number) and number > 0 do
+  cond do
+    rem(number, 15) == 0 -> "FizzBuzz"
+    rem(number, 3) == 0 -> "Fizz"
+    rem(number, 5) == 0 -> "Buzz"
+    true -> Integer.to_string(number)
+  end
+end
+```
+
+### Haskell
+
+ガード節による宣言的な定義です。
+
+```haskell
+generate :: Int -> String
+generate n
+  | n `mod` 15 == 0 = "FizzBuzz"
+  | n `mod` 3 == 0  = "Fizz"
+  | n `mod` 5 == 0  = "Buzz"
+  | otherwise        = show n
+```
+
+## 実装パターンの比較まとめ
+
+| 言語 | 分岐方法 | 型の安全性 | コード量 |
+|------|---------|-----------|---------|
+| Java | if/switch + 抽象クラス | コンパイル時チェック | 多い |
+| Python | if/elif + ABC | 型ヒントによる補完 | 中程度 |
+| TypeScript | switch + abstract class | コンパイル時チェック | 中程度 |
+| Ruby | if/case + 継承 | 動的ダックタイピング | 少ない |
+| Go | switch + interface | コンパイル時チェック | 中程度 |
+| PHP | match + 抽象クラス | 実行時チェック | 中程度 |
+| Rust | match（タプル） | コンパイル時 + 所有権 | 少ない |
+| C# | Factory + interface | コンパイル時チェック | 中程度 |
+| F# | match + 判別共用体 | コンパイル時 + 網羅性 | 少ない |
+| Clojure | cond + protocol | 実行時チェック | 少ない |
+| Scala | match + ガード節 | コンパイル時チェック | 少ない |
+| Elixir | cond + ガード節 | 実行時チェック | 少ない |
+| Haskell | ガード節 | コンパイル時 + 型クラス | 非常に少ない |
+
+## まとめ
+
+12 言語の概要を俯瞰すると、以下の傾向が見えてきます。
+
+1. **OOP 言語**（Java, C#, PHP）は、クラス階層とインターフェースにより構造化された FizzBuzz 実装となります
+2. **FP 言語**（Haskell, Clojure, Elixir, F#）は、パターンマッチングや条件式で簡潔に表現できます
+3. **マルチパラダイム言語**（Rust, Scala, TypeScript, Python, Ruby, Go）は、状況に応じて OOP と FP を使い分けることができます
+4. **パターンマッチング**を持つ言語（Rust, Scala, F#, Haskell, Elixir）は、FizzBuzz のような条件分岐を特に簡潔に書けます
+
+次章では、これらの言語のテストフレームワークを詳しく比較します。