@k2works/claude-code-booster 4.8.0 → 4.11.0

package/lib/assets/docs/article/getting-start-tdd/integration/03-tdd-pattern-comparison.md

@@ -1,445 +1,445 @@
-# パラダイム別 TDD パターン比較
-
-本章では、OOP と FP それぞれのパラダイムにおける TDD の進め方の違いを比較します。同じ FizzBuzz 問題でも、パラダイムによってテストの書き方、リファクタリングの方向性、設計パターンの適用方法が大きく異なります。
-
-## OOP のインターフェース / クラスを活用した TDD
-
-OOP 言語では、抽象クラスやインターフェースを定義し、具象クラスで実装を提供するという流れで TDD を進めます。
-
-### TDD サイクルの特徴
-
-1. **Red**: インターフェースに対するテストを書く
-2. **Green**: 具象クラスで最小限の実装を提供する
-3. **Refactor**: 共通処理を基底クラスに引き上げる
-
-### Java の例
-
-```java
-// Step 1: インターフェース（抽象クラス）を定義
-public abstract class FizzBuzzType {
-    public abstract FizzBuzzValue generate(int number);
-}
-
-// Step 2: テストを書く
-@Test
-void _1を渡したら文字列1を返す() {
-    FizzBuzzType type = FizzBuzzType.create(1);
-    assertEquals("1", type.generate(1).getValue());
-}
-
-// Step 3: 具象クラスで実装
-public class FizzBuzzType01 extends FizzBuzzType {
-    @Override
-    public FizzBuzzValue generate(int number) {
-        if (isFizzBuzz(number)) return new FizzBuzzValue(number, "FizzBuzz");
-        if (isFizz(number)) return new FizzBuzzValue(number, "Fizz");
-        if (isBuzz(number)) return new FizzBuzzValue(number, "Buzz");
-        return new FizzBuzzValue(number, String.valueOf(number));
-    }
-}
-```
-
-### C# の例
-
-```csharp
-// インターフェースを定義
-public interface IFizzBuzzType
-{
-    FizzBuzzValue Generate(int number);
-}
-
-// テストを書く
-[Fact]
-public void Generate_1を渡すと文字列1を返す()
-{
-    IFizzBuzzType type = FizzBuzzTypeFactory.Create(FizzBuzzTypeName.Standard);
-    Assert.Equal("1", type.Generate(1).Value);
-}
-```
-
-### PHP の例
-
-```php
-// 抽象クラスを定義
-abstract class FizzBuzzType
-{
-    abstract public function generate(int $number): FizzBuzzValue;
-}
-
-// テストを書く
-public function test_1を渡したら文字列1を返す(): void
-{
-    $type = FizzBuzz::create(1);
-    $this->assertSame('1', $type->generate(1)->getValue());
-}
-```
-
-## FP の型 / パターンマッチを活用した TDD
-
-FP 言語では、純粋関数とパターンマッチングを中心に TDD を進めます。
-
-### TDD サイクルの特徴
-
-1. **Red**: 純粋関数のテストを書く（入力と出力の対応を検証）
-2. **Green**: パターンマッチングで最小限の実装を提供する
-3. **Refactor**: 関数の合成や型の洗練で抽象化する
-
-### Haskell の例
-
-```haskell
--- Step 1: テストを書く
-it "1 を渡すと '1' を返す" $
-  generate 1 `shouldBe` "1"
-
-it "3 の倍数を渡すと 'Fizz' を返す" $
-  generate 3 `shouldBe` "Fizz"
-
--- Step 2: ガード節で実装
-generate :: Int -> String
-generate n
-  | n `mod` 15 == 0 = "FizzBuzz"
-  | n `mod` 3 == 0  = "Fizz"
-  | n `mod` 5 == 0  = "Buzz"
-  | otherwise        = show n
-```
-
-### F# の例
-
-```fsharp
-// 判別共用体で型を定義
-type FizzBuzzType =
-    | Standard
-    | NumberOnly
-    | FizzBuzzOnly
-
-// パターンマッチングで実装
-let generate (fizzBuzzType: FizzBuzzType) (number: int) =
-    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)
-```
-
-### 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
-```
-
-### Clojure の例
-
-```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)))
-
-;; テスト
-(deftest fizzbuzz-test
-  (testing "1 を渡したら文字列 1 を返す"
-    (is (= "1" (fizzbuzz 1)))))
-```
-
-## ポリモーフィズムの実現方法の比較
-
-ポリモーフィズム（多態性）は FizzBuzz の複数タイプ（通常、数値のみ、FizzBuzz のみ）を切り替える際に重要な概念です。各言語でその実現方法が異なります。
-
-### interface（Java, Go, C#, TypeScript, PHP）
-
-```java
-// Java: 抽象クラスによる多態性
-public abstract class FizzBuzzType {
-    public abstract FizzBuzzValue generate(int number);
-}
-```
-
-```go
-// Go: インターフェースによる多態性
-type FizzBuzzType interface {
-    Generate(number int) FizzBuzzValue
-}
-```
-
-```csharp
-// C#: インターフェースによる多態性
-public interface IFizzBuzzType
-{
-    FizzBuzzValue Generate(int number);
-}
-```
-
-### trait（Rust, Scala）
-
-```rust
-// Rust: trait による多態性
-pub trait FizzBuzzType {
-    fn generate(&self, number: i32) -> FizzBuzzValue;
-}
-
-impl FizzBuzzType for FizzBuzzType01 {
-    fn generate(&self, number: i32) -> FizzBuzzValue {
-        // 実装
-    }
-}
-```
-
-```scala
-// Scala: sealed trait による多態性
-sealed trait FizzBuzzType:
-  def generate(number: Int): FizzBuzzValue
-
-case object Type01 extends FizzBuzzType:
-  def generate(number: Int): FizzBuzzValue = ???
-```
-
-### protocol（Clojure, Elixir）
-
-```clojure
-;; Clojure: protocol による多態性
-(defprotocol FizzBuzzType
-  (generate-string [this value]))
-
-(defrecord FizzBuzzType01 []
-  FizzBuzzType
-  (generate-string [_this value]
-    (let [n (:number value)]
-      (cond
-        (model/fizz-buzz? n) "FizzBuzz"
-        (model/fizz? n) "Fizz"
-        (model/buzz? n) "Buzz"
-        :else (str n)))))
-```
-
-### type class（Haskell）
-
-```haskell
--- Haskell: 型クラスによる多態性
-class Generatable a where
-  generateValue :: a -> Int -> String
-
--- 型クラスのインスタンス
-instance Generatable StandardType where
-  generateValue _ n
-    | n `mod` 15 == 0 = "FizzBuzz"
-    | n `mod` 3 == 0  = "Fizz"
-    | n `mod` 5 == 0  = "Buzz"
-    | otherwise        = show n
-```
-
-### 判別共用体 / ADT（F#, Haskell, Scala, Rust）
-
-```fsharp
-// F#: 判別共用体による多態性
-type FizzBuzzType =
-    | Standard
-    | NumberOnly
-    | FizzBuzzOnly
-
-let generate fizzBuzzType number =
-    match fizzBuzzType with
-    | Standard -> ...
-    | NumberOnly -> ...
-    | FizzBuzzOnly -> ...
-```
-
-### ダックタイピング（Python, Ruby）
-
-```python
-# Python: ダックタイピング + ABC
-class FizzBuzzType(ABC):
-    @abstractmethod
-    def generate(self, number: int) -> FizzBuzzValue:
-        pass
-```
-
-```ruby
-# Ruby: ダックタイピング
-class FizzBuzzType
-  def generate(number)
-    raise NotImplementedError
-  end
-end
-```
-
-### ポリモーフィズム比較まとめ
-
-| 方式 | 言語 | コンパイル時チェック | 網羅性チェック | 動的ディスパッチ |
-|------|------|-------------------|-------------|--------------|
-| interface | Java, C#, TypeScript, PHP | あり | なし | あり |
-| interface（構造的部分型） | Go | あり | なし | あり |
-| trait | Rust | あり | なし | あり（dyn trait） |
-| sealed trait | Scala | あり | あり | あり |
-| protocol | Clojure | なし | なし | あり |
-| protocol（Elixir） | Elixir | なし | なし | あり |
-| type class | Haskell | あり | あり（型レベル） | コンパイル時解決 |
-| 判別共用体 | F# | あり | あり | パターンマッチ |
-| ダックタイピング | Python, Ruby | なし | なし | あり |
-
-## コマンドパターンの各言語実装比較
-
-FizzBuzz プロジェクトでは、コマンドパターンを使って「単一値の生成」と「リストの生成」を統一的に扱っています。
-
-### Java
-
-```java
-public interface FizzBuzzCommand {
-    String execute();
-}
-
-public class FizzBuzzValueCommand implements FizzBuzzCommand {
-    private final FizzBuzzType type;
-    private final int number;
-
-    @Override
-    public String execute() {
-        return type.generate(number).getValue();
-    }
-}
-```
-
-### TypeScript
-
-```typescript
-interface FizzBuzzCommand {
-  execute(): string;
-}
-
-class FizzBuzzValueCommand implements FizzBuzzCommand {
-  constructor(
-    private readonly type: FizzBuzzType,
-    private readonly number: number
-  ) {}
-
-  execute(): string {
-    return this.type.generate(this.number).value;
-  }
-}
-```
-
-### Go
-
-```go
-type FizzBuzzCommand interface {
-    Execute() string
-}
-
-type FizzBuzzValueCommand struct {
-    FizzBuzzType FizzBuzzType
-    Number       int
-}
-
-func (c *FizzBuzzValueCommand) Execute() string {
-    return c.FizzBuzzType.Generate(c.Number).Value()
-}
-```
-
-### Rust
-
-```rust
-pub trait FizzBuzzCommand {
-    fn execute(&self) -> String;
-}
-
-pub struct FizzBuzzValueCommand {
-    pub fizz_buzz_type: Box<dyn FizzBuzzType>,
-    pub number: i32,
-}
-
-impl FizzBuzzCommand for FizzBuzzValueCommand {
-    fn execute(&self) -> String {
-        self.fizz_buzz_type.generate(self.number).value().to_string()
-    }
-}
-```
-
-### F#（関数で表現）
-
-```fsharp
-// F# ではコマンドパターンを関数で表現
-let executeValue (fizzBuzzType: FizzBuzzType) (number: int) : FizzBuzzValue =
-    generate fizzBuzzType number
-
-let executeList (fizzBuzzType: FizzBuzzType) (count: int) : FizzBuzzList =
-    [1..count]
-    |> List.map (generate fizzBuzzType)
-    |> createList
-```
-
-### Clojure（関数で表現）
-
-```clojure
-;; Clojure ではコマンドを高階関数で表現
-(defn execute-value [fizz-buzz-type number]
-  (generate-string fizz-buzz-type (->FizzBuzzValue number)))
-
-(defn execute-list [fizz-buzz-type count]
-  (mapv #(execute-value fizz-buzz-type %) (range 1 (inc count))))
-```
-
-### Haskell（関数で表現）
-
-```haskell
--- Haskell ではコマンドを関数適用で表現
-executeValue :: Int -> String
-executeValue = generate
-
-executeList :: Int -> [String]
-executeList n = map generate [1..n]
-```
-
-### コマンドパターンの比較
-
-| 言語 | 実現方法 | 特徴 |
-|------|---------|------|
-| Java | interface + class | 型安全、明示的なコマンドオブジェクト |
-| TypeScript | interface + class | 同上、ジェネリクス対応 |
-| Python | ABC + class | ダックタイピングで柔軟 |
-| Ruby | class + method | シンプルな OOP スタイル |
-| Go | interface + struct | 構造的部分型で暗黙的に実装 |
-| PHP | interface + class | 型宣言で安全 |
-| Rust | trait + struct | 所有権を考慮した設計が必要 |
-| C# | interface + class | .NET エコシステムと統合 |
-| F# | 関数 | 関数適用で自然に表現 |
-| Clojure | 関数 | 高階関数で柔軟に組み合わせ |
-| Scala | trait + case class / 関数 | OOP/FP 両方で表現可能 |
-| Elixir | 関数 | パイプラインで連鎖 |
-| Haskell | 関数 | 関数合成で自然に表現 |
-
-## OOP vs FP: TDD アプローチの対比
-
-| 観点 | OOP アプローチ | FP アプローチ |
-|------|-------------|-------------|
-| テスト対象 | オブジェクトの振る舞い | 関数の入出力 |
-| テストの構造化 | クラス / ネストクラス | describe / テストモジュール |
-| 仮実装 | ハードコーディング値を返す | 定数を返す |
-| 三角測量 | テストケース追加で一般化 | 同左 |
-| リファクタリング | 継承/委譲の導入 | 関数の合成/パターンの追加 |
-| 多態性の導入 | interface/abstract class | 判別共用体/型クラス/プロトコル |
-| デザインパターン | GoF パターンが直接適用 | 関数の組み合わせで表現 |
-| モック/スタブ | インターフェースを差し替え | 関数を差し替え |
-
-## まとめ
-
-1. **OOP 言語**では、インターフェースと具象クラスの階層を TDD で段階的に構築します。コマンドパターンなどの GoF パターンが直接適用できます
-2. **FP 言語**では、純粋関数のテストを書き、パターンマッチングで実装します。コマンドパターンは関数適用で自然に表現されます
-3. **マルチパラダイム言語**では、状況に応じて OOP と FP のアプローチを使い分けることができます
-4. **ポリモーフィズム**の実現方法は言語によって大きく異なりますが、すべて「同じインターフェースで異なる振る舞いを提供する」という本質は共通です
-
-次章では、型システムとエラーハンドリングの違いを比較します。
+# パラダイム別 TDD パターン比較
+
+本章では、OOP と FP それぞれのパラダイムにおける TDD の進め方の違いを比較します。同じ FizzBuzz 問題でも、パラダイムによってテストの書き方、リファクタリングの方向性、設計パターンの適用方法が大きく異なります。
+
+## OOP のインターフェース / クラスを活用した TDD
+
+OOP 言語では、抽象クラスやインターフェースを定義し、具象クラスで実装を提供するという流れで TDD を進めます。
+
+### TDD サイクルの特徴
+
+1. **Red**: インターフェースに対するテストを書く
+2. **Green**: 具象クラスで最小限の実装を提供する
+3. **Refactor**: 共通処理を基底クラスに引き上げる
+
+### Java の例
+
+```java
+// Step 1: インターフェース（抽象クラス）を定義
+public abstract class FizzBuzzType {
+    public abstract FizzBuzzValue generate(int number);
+}
+
+// Step 2: テストを書く
+@Test
+void _1を渡したら文字列1を返す() {
+    FizzBuzzType type = FizzBuzzType.create(1);
+    assertEquals("1", type.generate(1).getValue());
+}
+
+// Step 3: 具象クラスで実装
+public class FizzBuzzType01 extends FizzBuzzType {
+    @Override
+    public FizzBuzzValue generate(int number) {
+        if (isFizzBuzz(number)) return new FizzBuzzValue(number, "FizzBuzz");
+        if (isFizz(number)) return new FizzBuzzValue(number, "Fizz");
+        if (isBuzz(number)) return new FizzBuzzValue(number, "Buzz");
+        return new FizzBuzzValue(number, String.valueOf(number));
+    }
+}
+```
+
+### C# の例
+
+```csharp
+// インターフェースを定義
+public interface IFizzBuzzType
+{
+    FizzBuzzValue Generate(int number);
+}
+
+// テストを書く
+[Fact]
+public void Generate_1を渡すと文字列1を返す()
+{
+    IFizzBuzzType type = FizzBuzzTypeFactory.Create(FizzBuzzTypeName.Standard);
+    Assert.Equal("1", type.Generate(1).Value);
+}
+```
+
+### PHP の例
+
+```php
+// 抽象クラスを定義
+abstract class FizzBuzzType
+{
+    abstract public function generate(int $number): FizzBuzzValue;
+}
+
+// テストを書く
+public function test_1を渡したら文字列1を返す(): void
+{
+    $type = FizzBuzz::create(1);
+    $this->assertSame('1', $type->generate(1)->getValue());
+}
+```
+
+## FP の型 / パターンマッチを活用した TDD
+
+FP 言語では、純粋関数とパターンマッチングを中心に TDD を進めます。
+
+### TDD サイクルの特徴
+
+1. **Red**: 純粋関数のテストを書く（入力と出力の対応を検証）
+2. **Green**: パターンマッチングで最小限の実装を提供する
+3. **Refactor**: 関数の合成や型の洗練で抽象化する
+
+### Haskell の例
+
+```haskell
+-- Step 1: テストを書く
+it "1 を渡すと '1' を返す" $
+  generate 1 `shouldBe` "1"
+
+it "3 の倍数を渡すと 'Fizz' を返す" $
+  generate 3 `shouldBe` "Fizz"
+
+-- Step 2: ガード節で実装
+generate :: Int -> String
+generate n
+  | n `mod` 15 == 0 = "FizzBuzz"
+  | n `mod` 3 == 0  = "Fizz"
+  | n `mod` 5 == 0  = "Buzz"
+  | otherwise        = show n
+```
+
+### F# の例
+
+```fsharp
+// 判別共用体で型を定義
+type FizzBuzzType =
+    | Standard
+    | NumberOnly
+    | FizzBuzzOnly
+
+// パターンマッチングで実装
+let generate (fizzBuzzType: FizzBuzzType) (number: int) =
+    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)
+```
+
+### 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
+```
+
+### Clojure の例
+
+```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)))
+
+;; テスト
+(deftest fizzbuzz-test
+  (testing "1 を渡したら文字列 1 を返す"
+    (is (= "1" (fizzbuzz 1)))))
+```
+
+## ポリモーフィズムの実現方法の比較
+
+ポリモーフィズム（多態性）は FizzBuzz の複数タイプ（通常、数値のみ、FizzBuzz のみ）を切り替える際に重要な概念です。各言語でその実現方法が異なります。
+
+### interface（Java, Go, C#, TypeScript, PHP）
+
+```java
+// Java: 抽象クラスによる多態性
+public abstract class FizzBuzzType {
+    public abstract FizzBuzzValue generate(int number);
+}
+```
+
+```go
+// Go: インターフェースによる多態性
+type FizzBuzzType interface {
+    Generate(number int) FizzBuzzValue
+}
+```
+
+```csharp
+// C#: インターフェースによる多態性
+public interface IFizzBuzzType
+{
+    FizzBuzzValue Generate(int number);
+}
+```
+
+### trait（Rust, Scala）
+
+```rust
+// Rust: trait による多態性
+pub trait FizzBuzzType {
+    fn generate(&self, number: i32) -> FizzBuzzValue;
+}
+
+impl FizzBuzzType for FizzBuzzType01 {
+    fn generate(&self, number: i32) -> FizzBuzzValue {
+        // 実装
+    }
+}
+```
+
+```scala
+// Scala: sealed trait による多態性
+sealed trait FizzBuzzType:
+  def generate(number: Int): FizzBuzzValue
+
+case object Type01 extends FizzBuzzType:
+  def generate(number: Int): FizzBuzzValue = ???
+```
+
+### protocol（Clojure, Elixir）
+
+```clojure
+;; Clojure: protocol による多態性
+(defprotocol FizzBuzzType
+  (generate-string [this value]))
+
+(defrecord FizzBuzzType01 []
+  FizzBuzzType
+  (generate-string [_this value]
+    (let [n (:number value)]
+      (cond
+        (model/fizz-buzz? n) "FizzBuzz"
+        (model/fizz? n) "Fizz"
+        (model/buzz? n) "Buzz"
+        :else (str n)))))
+```
+
+### type class（Haskell）
+
+```haskell
+-- Haskell: 型クラスによる多態性
+class Generatable a where
+  generateValue :: a -> Int -> String
+
+-- 型クラスのインスタンス
+instance Generatable StandardType where
+  generateValue _ n
+    | n `mod` 15 == 0 = "FizzBuzz"
+    | n `mod` 3 == 0  = "Fizz"
+    | n `mod` 5 == 0  = "Buzz"
+    | otherwise        = show n
+```
+
+### 判別共用体 / ADT（F#, Haskell, Scala, Rust）
+
+```fsharp
+// F#: 判別共用体による多態性
+type FizzBuzzType =
+    | Standard
+    | NumberOnly
+    | FizzBuzzOnly
+
+let generate fizzBuzzType number =
+    match fizzBuzzType with
+    | Standard -> ...
+    | NumberOnly -> ...
+    | FizzBuzzOnly -> ...
+```
+
+### ダックタイピング（Python, Ruby）
+
+```python
+# Python: ダックタイピング + ABC
+class FizzBuzzType(ABC):
+    @abstractmethod
+    def generate(self, number: int) -> FizzBuzzValue:
+        pass
+```
+
+```ruby
+# Ruby: ダックタイピング
+class FizzBuzzType
+  def generate(number)
+    raise NotImplementedError
+  end
+end
+```
+
+### ポリモーフィズム比較まとめ
+
+| 方式 | 言語 | コンパイル時チェック | 網羅性チェック | 動的ディスパッチ |
+|------|------|-------------------|-------------|--------------|
+| interface | Java, C#, TypeScript, PHP | あり | なし | あり |
+| interface（構造的部分型） | Go | あり | なし | あり |
+| trait | Rust | あり | なし | あり（dyn trait） |
+| sealed trait | Scala | あり | あり | あり |
+| protocol | Clojure | なし | なし | あり |
+| protocol（Elixir） | Elixir | なし | なし | あり |
+| type class | Haskell | あり | あり（型レベル） | コンパイル時解決 |
+| 判別共用体 | F# | あり | あり | パターンマッチ |
+| ダックタイピング | Python, Ruby | なし | なし | あり |
+
+## コマンドパターンの各言語実装比較
+
+FizzBuzz プロジェクトでは、コマンドパターンを使って「単一値の生成」と「リストの生成」を統一的に扱っています。
+
+### Java
+
+```java
+public interface FizzBuzzCommand {
+    String execute();
+}
+
+public class FizzBuzzValueCommand implements FizzBuzzCommand {
+    private final FizzBuzzType type;
+    private final int number;
+
+    @Override
+    public String execute() {
+        return type.generate(number).getValue();
+    }
+}
+```
+
+### TypeScript
+
+```typescript
+interface FizzBuzzCommand {
+  execute(): string;
+}
+
+class FizzBuzzValueCommand implements FizzBuzzCommand {
+  constructor(
+    private readonly type: FizzBuzzType,
+    private readonly number: number
+  ) {}
+
+  execute(): string {
+    return this.type.generate(this.number).value;
+  }
+}
+```
+
+### Go
+
+```go
+type FizzBuzzCommand interface {
+    Execute() string
+}
+
+type FizzBuzzValueCommand struct {
+    FizzBuzzType FizzBuzzType
+    Number       int
+}
+
+func (c *FizzBuzzValueCommand) Execute() string {
+    return c.FizzBuzzType.Generate(c.Number).Value()
+}
+```
+
+### Rust
+
+```rust
+pub trait FizzBuzzCommand {
+    fn execute(&self) -> String;
+}
+
+pub struct FizzBuzzValueCommand {
+    pub fizz_buzz_type: Box<dyn FizzBuzzType>,
+    pub number: i32,
+}
+
+impl FizzBuzzCommand for FizzBuzzValueCommand {
+    fn execute(&self) -> String {
+        self.fizz_buzz_type.generate(self.number).value().to_string()
+    }
+}
+```
+
+### F#（関数で表現）
+
+```fsharp
+// F# ではコマンドパターンを関数で表現
+let executeValue (fizzBuzzType: FizzBuzzType) (number: int) : FizzBuzzValue =
+    generate fizzBuzzType number
+
+let executeList (fizzBuzzType: FizzBuzzType) (count: int) : FizzBuzzList =
+    [1..count]
+    |> List.map (generate fizzBuzzType)
+    |> createList
+```
+
+### Clojure（関数で表現）
+
+```clojure
+;; Clojure ではコマンドを高階関数で表現
+(defn execute-value [fizz-buzz-type number]
+  (generate-string fizz-buzz-type (->FizzBuzzValue number)))
+
+(defn execute-list [fizz-buzz-type count]
+  (mapv #(execute-value fizz-buzz-type %) (range 1 (inc count))))
+```
+
+### Haskell（関数で表現）
+
+```haskell
+-- Haskell ではコマンドを関数適用で表現
+executeValue :: Int -> String
+executeValue = generate
+
+executeList :: Int -> [String]
+executeList n = map generate [1..n]
+```
+
+### コマンドパターンの比較
+
+| 言語 | 実現方法 | 特徴 |
+|------|---------|------|
+| Java | interface + class | 型安全、明示的なコマンドオブジェクト |
+| TypeScript | interface + class | 同上、ジェネリクス対応 |
+| Python | ABC + class | ダックタイピングで柔軟 |
+| Ruby | class + method | シンプルな OOP スタイル |
+| Go | interface + struct | 構造的部分型で暗黙的に実装 |
+| PHP | interface + class | 型宣言で安全 |
+| Rust | trait + struct | 所有権を考慮した設計が必要 |
+| C# | interface + class | .NET エコシステムと統合 |
+| F# | 関数 | 関数適用で自然に表現 |
+| Clojure | 関数 | 高階関数で柔軟に組み合わせ |
+| Scala | trait + case class / 関数 | OOP/FP 両方で表現可能 |
+| Elixir | 関数 | パイプラインで連鎖 |
+| Haskell | 関数 | 関数合成で自然に表現 |
+
+## OOP vs FP: TDD アプローチの対比
+
+| 観点 | OOP アプローチ | FP アプローチ |
+|------|-------------|-------------|
+| テスト対象 | オブジェクトの振る舞い | 関数の入出力 |
+| テストの構造化 | クラス / ネストクラス | describe / テストモジュール |
+| 仮実装 | ハードコーディング値を返す | 定数を返す |
+| 三角測量 | テストケース追加で一般化 | 同左 |
+| リファクタリング | 継承/委譲の導入 | 関数の合成/パターンの追加 |
+| 多態性の導入 | interface/abstract class | 判別共用体/型クラス/プロトコル |
+| デザインパターン | GoF パターンが直接適用 | 関数の組み合わせで表現 |
+| モック/スタブ | インターフェースを差し替え | 関数を差し替え |
+
+## まとめ
+
+1. **OOP 言語**では、インターフェースと具象クラスの階層を TDD で段階的に構築します。コマンドパターンなどの GoF パターンが直接適用できます
+2. **FP 言語**では、純粋関数のテストを書き、パターンマッチングで実装します。コマンドパターンは関数適用で自然に表現されます
+3. **マルチパラダイム言語**では、状況に応じて OOP と FP のアプローチを使い分けることができます
+4. **ポリモーフィズム**の実現方法は言語によって大きく異なりますが、すべて「同じインターフェースで異なる振る舞いを提供する」という本質は共通です
+
+次章では、型システムとエラーハンドリングの違いを比較します。