@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +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. **ポリモーフィズム**の実現方法は言語によって大きく異なりますが、すべて「同じインターフェースで異なる振る舞いを提供する」という本質は共通です
+
+次章では、型システムとエラーハンドリングの違いを比較します。