@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,175 @@
+# 第 8 章: 判別共用体とパターンマッチ
+
+## 8.1 はじめに
+
+前章ではレコード型とモジュールによるカプセル化を実現しました。この章では F# の最も強力な機能の一つである **判別共用体（Discriminated Union）** と **パターンマッチ** を導入して、FizzBuzz のタイプを型安全に表現します。
+
+## 8.2 判別共用体の導入
+
+### FizzBuzzType 判別共用体
+
+FizzBuzz の動作モードを表現する判別共用体を定義します。
+
+```fsharp
+type FizzBuzzType =
+    | Standard
+    | NumberOnly
+    | FizzBuzzOnly
+```
+
+この定義により、FizzBuzz の動作モードを 3 つの明確な型で表現できます。
+
+- `Standard`: 通常の FizzBuzz（3 の倍数 → "Fizz"、5 の倍数 → "Buzz"、15 の倍数 → "FizzBuzz"）
+- `NumberOnly`: 常に数値を文字列にして返す
+- `FizzBuzzOnly`: 15 の倍数のときだけ "FizzBuzz"、それ以外は数値を返す
+
+### 判別共用体の特徴
+
+F# の判別共用体は Rust の `enum` や Java の sealed interface に相当します。
+
+| 特徴 | F# 判別共用体 | Rust enum | Java |
+|------|-------------|-----------|------|
+| 定義 | `type T = A \| B` | `enum T { A, B }` | `sealed interface` |
+| データ保持 | `A of int` | `A(i32)` | レコードクラス |
+| 網羅性チェック | コンパイラが検出 | コンパイラが検出 | Java 21+ で対応 |
+| パターンマッチ | `match...with` | `match` | `switch`(Java 21+) |
+
+## 8.3 パターンマッチによる generate 関数
+
+### テストを書く
+
+まず各タイプに対応するテストを追加します。
+
+```fsharp
+module FizzBuzzTypeTests =
+
+    [<Fact>]
+    let ``Standard_数を文字列にして返す`` () =
+        let result = Domain.generate Standard 1
+        Assert.Equal("1", result.Value)
+
+    [<Fact>]
+    let ``Standard_三の倍数のときはFizzを返す`` () =
+        let result = Domain.generate Standard 3
+        Assert.Equal("Fizz", result.Value)
+
+    [<Fact>]
+    let ``Standard_五の倍数のときはBuzzを返す`` () =
+        let result = Domain.generate Standard 5
+        Assert.Equal("Buzz", result.Value)
+
+    [<Fact>]
+    let ``Standard_三と五の倍数のときはFizzBuzzを返す`` () =
+        let result = Domain.generate Standard 15
+        Assert.Equal("FizzBuzz", result.Value)
+
+    [<Fact>]
+    let ``NumberOnly_常に数値を文字列にして返す`` () =
+        Assert.Equal("1", (Domain.generate NumberOnly 1).Value)
+        Assert.Equal("3", (Domain.generate NumberOnly 3).Value)
+        Assert.Equal("5", (Domain.generate NumberOnly 5).Value)
+
+    [<Fact>]
+    let ``FizzBuzzOnly_十五の倍数のときはFizzBuzzを返す`` () =
+        Assert.Equal("FizzBuzz", (Domain.generate FizzBuzzOnly 15).Value)
+        Assert.Equal("FizzBuzz", (Domain.generate FizzBuzzOnly 30).Value)
+
+    [<Fact>]
+    let ``FizzBuzzOnly_十五の倍数以外は数値を文字列にして返す`` () =
+        Assert.Equal("1", (Domain.generate FizzBuzzOnly 1).Value)
+        Assert.Equal("3", (Domain.generate FizzBuzzOnly 3).Value)
+```
+
+### generate 関数の実装
+
+判別共用体をパターンマッチで分岐させます。
+
+```fsharp
+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)
+```
+
+```bash
+$ dotnet test
+  合計: 17、成功: 17、失敗: 0、スキップ: 0
+```
+
+## 8.4 網羅的パターンマッチ
+
+F# のパターンマッチの最大の利点は **網羅性チェック** です。もし新しいタイプを追加して、対応するパターンを書き忘れると、コンパイラが警告を出します。
+
+```fsharp
+// 新しいタイプを追加
+type FizzBuzzType =
+    | Standard
+    | NumberOnly
+    | FizzBuzzOnly
+    | CustomFizz    // 新しいタイプ
+
+// generate 関数で CustomFizz のパターンを書き忘れると...
+// 警告 FS0025: 不完全なパターンマッチ。この式が取り得る値の一部が処理されません。
+```
+
+この網羅性チェックにより、新しい判別共用体のケースを追加した際に、対応漏れをコンパイル時に検出できます。Rust の `match` と同様に、F# はすべてのパターンを処理することを要求します。
+
+## 8.5 判別共用体とオブジェクト指向の比較
+
+### Before: オブジェクト指向アプローチ
+
+Rust や Java では、タイプごとにクラス/構造体を作成し、トレイト/インターフェースで共通化します。
+
+```fsharp
+// OOP アプローチ（F# でも可能だが非推奨）
+[<AbstractClass>]
+type FizzBuzzType() =
+    abstract member Generate: int -> string
+
+type StandardType() =
+    inherit FizzBuzzType()
+    override this.Generate(number) = ...
+
+type NumberOnlyType() =
+    inherit FizzBuzzType()
+    override this.Generate(number) = ...
+```
+
+### After: 関数型アプローチ
+
+```fsharp
+// FP アプローチ（F# らしい）
+type FizzBuzzType =
+    | Standard
+    | NumberOnly
+    | FizzBuzzOnly
+
+let generate fizzBuzzType number =
+    match fizzBuzzType with
+    | Standard -> ...
+    | NumberOnly -> ...
+    | FizzBuzzOnly -> ...
+```
+
+関数型アプローチでは、データ（判別共用体）と振る舞い（関数）が分離されています。新しいタイプの追加は判別共用体にケースを追加し、関数のパターンマッチに対応する分岐を追加するだけです。
+
+## 8.6 まとめ
+
+この章では以下を学びました。
+
+| 概念 | F# の実現方法 | 利点 |
+|------|---------------|------|
+| 判別共用体 | `type T = A \| B \| C` | タイプの明確な表現 |
+| パターンマッチ | `match...with` | 網羅的な条件分岐 |
+| 網羅性チェック | コンパイラ警告 | パターン漏れの防止 |
+| カリー化 | `generate type number` | 部分適用が可能 |
+
+次章では、**モジュール設計** と **型による設計** を通じて、FizzBuzz プログラム全体のアーキテクチャを整理します。

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

@@ -0,0 +1,222 @@
+# 第 9 章: モジュール設計と型による設計
+
+## 9.1 はじめに
+
+前章では判別共用体とパターンマッチを導入しました。この章では、FizzBuzz プログラム全体を **モジュール分割** し、**型による設計（Type-Driven Design）** でアーキテクチャを整理します。
+
+## 9.2 現在のコード構造の課題
+
+これまでの実装では、すべてのコードが 1 つのモジュールに集約されています。プログラムの規模が大きくなると以下の課題が生じます。
+
+- **責務の混在**: ドメインロジックとアプリケーションロジックが分離されていない
+- **再利用性の低下**: 特定の機能だけを利用することが困難
+- **テストの複雑化**: 依存関係が絡み合いテストが書きにくい
+
+## 9.3 モジュール分割
+
+### Domain モジュール
+
+ビジネスルールとデータ型を定義するモジュールです。
+
+```fsharp
+module Domain =
+
+    // 値オブジェクト
+    type FizzBuzzValue =
+        { Number: int
+          Value: string }
+
+        override this.ToString() = sprintf "%d:%s" this.Number this.Value
+
+    let createValue number value = { Number = number; Value = value }
+
+    // 判別共用体
+    type FizzBuzzType =
+        | Standard
+        | NumberOnly
+        | FizzBuzzOnly
+
+    // ドメインロジック
+    let private isFizz number = number % 3 = 0
+    let private isBuzz number = number % 5 = 0
+    let private isFizzBuzz number = isFizz number && isBuzz number
+
+    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)
+```
+
+### FizzBuzzList 型
+
+FizzBuzzValue のコレクションを専用の型でラップする **ファーストクラスコレクション** を定義します。
+
+```fsharp
+    type FizzBuzzList =
+        { Values: FizzBuzzValue list }
+
+        member this.Count = this.Values.Length
+        member this.Get(index) = this.Values.[index]
+
+        member this.Filter(predicate: FizzBuzzValue -> bool) =
+            { Values = this.Values |> List.filter predicate }
+
+        member this.FindFirst(predicate: FizzBuzzValue -> bool) =
+            this.Values |> List.tryFind predicate
+
+        member this.ToStringValues() =
+            this.Values |> List.map (fun v -> v.Value)
+
+        member this.Add(value: FizzBuzzValue) =
+            { Values = this.Values @ [ value ] }
+
+        override this.ToString() =
+            this.Values
+            |> List.map (fun v -> v.ToString())
+            |> String.concat ", "
+
+    let emptyList = { Values = [] }
+
+    let createList (values: FizzBuzzValue list) = { Values = values }
+```
+
+### テストを書く
+
+```fsharp
+module FizzBuzzListTests =
+
+    [<Fact>]
+    let ``空のリストを作成できる`` () =
+        let list = emptyList
+        Assert.Equal(0, list.Count)
+
+    [<Fact>]
+    let ``値を追加できる`` () =
+        let list = emptyList
+        let newList = list.Add(createValue 1 "1")
+        Assert.Equal(1, newList.Count)
+        Assert.Equal(0, list.Count)  // 元のリストは不変
+
+    [<Fact>]
+    let ``フィルタリングできる`` () =
+        let list =
+            createList
+                [ createValue 1 "1"
+                  createValue 3 "Fizz"
+                  createValue 5 "Buzz"
+                  createValue 15 "FizzBuzz" ]
+        let filtered = list.Filter(fun v -> v.Value = "Fizz")
+        Assert.Equal(1, filtered.Count)
+```
+
+`list.Add` は新しいリストを返し、元のリストは変更されません。F# のレコード型は不変であるため、すべての操作が新しい値を返します。
+
+### Application モジュール
+
+ユースケースを実行するモジュールです。Domain モジュールに依存します。
+
+```fsharp
+module Application =
+    open Domain
+
+    let executeValue (fizzBuzzType: FizzBuzzType) (number: int) : FizzBuzzValue =
+        generate fizzBuzzType number
+
+    let executeList (fizzBuzzType: FizzBuzzType) (count: int) : FizzBuzzList =
+        [ 1..count ]
+        |> List.map (generate fizzBuzzType)
+        |> createList
+```
+
+### FizzBuzz モジュール（公開 API）
+
+外部に公開するシンプルな API を提供するモジュールです。
+
+```fsharp
+module FizzBuzz =
+    open Domain
+    open Application
+
+    let generate (number: int) : string =
+        let value = executeValue Standard number
+        value.Value
+
+    let generateList (count: int) : string list =
+        let list = executeList Standard count
+        list.ToStringValues()
+```
+
+### テストを書く
+
+```fsharp
+module ApplicationTests =
+
+    [<Fact>]
+    let ``executeValueで単一値を取得できる`` () =
+        let result = executeValue Standard 3
+        Assert.Equal("Fizz", result.Value)
+
+    [<Fact>]
+    let ``executeListでリストを生成できる`` () =
+        let result = executeList Standard 100
+        Assert.Equal(100, result.Count)
+```
+
+## 9.4 依存関係
+
+```
+FizzBuzz (公開 API)
+    ↓
+Application (ユースケース)
+    ↓
+Domain (ドメインモデル)
+```
+
+- `FizzBuzz` モジュールは `Application` と `Domain` に依存
+- `Application` モジュールは `Domain` に依存
+- `Domain` モジュールは外部に依存しない（純粋なドメインロジック）
+- 逆方向の依存は存在しない（単方向依存）
+
+## 9.5 型による設計の利点
+
+### 不正な状態を表現できない
+
+判別共用体を使うことで、存在しないタイプを指定することがコンパイル時に防止されます。
+
+```fsharp
+// 型安全: コンパイルエラーになる
+let result = generate InvalidType 1  // FizzBuzzType に InvalidType は定義されていない
+
+// 型安全: 正しい使い方
+let result = generate Standard 1
+```
+
+### SOLID 原則の適用
+
+| 原則 | 適用内容 |
+|------|---------|
+| SRP | Domain / Application / FizzBuzz の責務分離 |
+| OCP | 判別共用体にケースを追加して拡張 |
+| LSP | FizzBuzzType の各ケースは同じ generate 関数で処理 |
+| ISP | 各モジュールは必要な関数のみ公開 |
+| DIP | Application は Domain の型に依存（抽象に依存） |
+
+## 9.6 まとめ
+
+この章では以下を実現しました。
+
+| モジュール | 責務 | 含まれる型 |
+|-----------|------|-----------|
+| `Domain` | ドメインモデルとビジネスルール | FizzBuzzValue, FizzBuzzType, FizzBuzzList |
+| `Application` | ユースケースの実行 | executeValue, executeList |
+| `FizzBuzz` | 公開 API | generate, generateList |
+
+第 3 部を通じて、F# のレコード型、判別共用体、モジュールシステムを使った関数型アプローチによる設計を学びました。次の第 4 部では、F# の高度な関数型プログラミング機能（高階関数、関数合成、エラーハンドリング）を活用します。

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

@@ -0,0 +1,189 @@
+# 第 10 章: 高階関数と関数合成
+
+## 10.1 はじめに
+
+F# は関数型プログラミングの機能を豊富にサポートしています。この章では **パイプライン演算子**、**部分適用**、**カリー化**、**関数合成** を中心に、高階関数の考え方を学びます。
+
+## 10.2 パイプライン演算子
+
+F# の **パイプライン演算子** `|>` は、値を関数に渡すための構文です。Unix のパイプ `|` と同様に、データの流れを左から右に読めるようにします。
+
+```fsharp
+// 通常の関数呼び出し（内側から外側へ読む）
+List.map (fun v -> v.Value) (List.filter (fun v -> v.Number > 5) values)
+
+// パイプライン演算子（左から右へ読む）
+values
+|> List.filter (fun v -> v.Number > 5)
+|> List.map (fun v -> v.Value)
+```
+
+パイプライン演算子により、データの変換処理が自然な流れで読めるようになります。
+
+### FizzBuzz での活用例
+
+```fsharp
+// 1 から 100 までの FizzBuzz リストを生成
+let fizzBuzzList =
+    [ 1..100 ]
+    |> List.map (generate Standard)
+    |> createList
+
+// リストから Fizz の値だけを抽出してカウント
+let fizzCount =
+    fizzBuzzList.Values
+    |> List.filter (fun v -> v.Value = "Fizz")
+    |> List.length
+```
+
+## 10.3 カリー化と部分適用
+
+### カリー化
+
+F# の関数はデフォルトで **カリー化** されています。複数の引数を取る関数は、1 つの引数を取り「残りの引数を取る関数」を返す関数として解釈されます。
+
+```fsharp
+// generate は FizzBuzzType -> int -> FizzBuzzValue
+// つまり、FizzBuzzType を受け取り、(int -> FizzBuzzValue) を返す関数
+let generate (fizzBuzzType: FizzBuzzType) (number: int) : FizzBuzzValue = ...
+```
+
+### 部分適用
+
+カリー化された関数に一部の引数だけを渡すことで、新しい関数を作成できます。
+
+```fsharp
+// generate に Standard だけを適用して新しい関数を作成
+let generateStandard = generate Standard
+// generateStandard は int -> FizzBuzzValue 型
+
+// 使用例
+let result = generateStandard 15
+Assert.Equal("FizzBuzz", result.Value)
+
+// List.map と組み合わせる
+let values = [ 1..10 ] |> List.map generateStandard
+```
+
+Rust ではクロージャ `|n| generate(n, Standard)` で同様のことを実現しますが、F# ではカリー化のおかげで自然に部分適用が行えます。
+
+### テストで確認
+
+```fsharp
+[<Fact>]
+let ``部分適用でStandard専用の関数を作成できる`` () =
+    let generateStandard = generate Standard
+    Assert.Equal("FizzBuzz", (generateStandard 15).Value)
+    Assert.Equal("Fizz", (generateStandard 3).Value)
+    Assert.Equal("Buzz", (generateStandard 5).Value)
+
+[<Fact>]
+let ``部分適用でNumberOnly専用の関数を作成できる`` () =
+    let generateNumberOnly = generate NumberOnly
+    Assert.Equal("3", (generateNumberOnly 3).Value)
+    Assert.Equal("15", (generateNumberOnly 15).Value)
+```
+
+## 10.4 関数合成演算子
+
+### >> 演算子
+
+F# の **関数合成演算子** `>>` は、2 つの関数を連結して新しい関数を作成します。
+
+```fsharp
+// f >> g は「まず f を適用し、その結果に g を適用する」関数
+let classify = generate Standard
+let toString (value: FizzBuzzValue) = value.Value
+
+// 関数合成で新しい関数を作成
+let fizzBuzz = classify >> toString
+// fizzBuzz は int -> string 型
+
+// 使用例
+Assert.Equal("FizzBuzz", fizzBuzz 15)
+Assert.Equal("1", fizzBuzz 1)
+```
+
+### パイプライン演算子との違い
+
+| 演算子 | 用途 | 型 |
+|--------|------|-----|
+| `\|>` | 値を関数に渡す | `'a -> ('a -> 'b) -> 'b` |
+| `>>` | 関数を合成する | `('a -> 'b) -> ('b -> 'c) -> ('a -> 'c)` |
+
+```fsharp
+// パイプライン: 値に対して関数を適用
+15 |> classify |> toString  // "FizzBuzz"
+
+// 関数合成: 関数同士を結合して新しい関数を作成
+let fizzBuzz = classify >> toString
+fizzBuzz 15  // "FizzBuzz"
+```
+
+パイプライン演算子は「値」を流すのに対し、関数合成演算子は「関数」を結合します。
+
+## 10.5 高階関数
+
+### 関数を引数として受け取る
+
+```fsharp
+// applyToRange: 指定した関数を範囲に適用する高階関数
+let applyToRange (f: int -> 'a) (start: int) (end': int) : 'a list =
+    [ start..end' ] |> List.map f
+
+// 使用例
+let fizzBuzzRange = applyToRange (generate Standard >> (fun v -> v.Value)) 1 20
+// ["1"; "2"; "Fizz"; "4"; "Buzz"; ...]
+```
+
+### FizzBuzzList への関数型メソッド追加
+
+```fsharp
+member this.CountByValue() =
+    this.Values
+    |> List.groupBy (fun v -> v.Value)
+    |> List.map (fun (key, group) -> (key, List.length group))
+    |> Map.ofList
+```
+
+### テストで確認
+
+```fsharp
+[<Fact>]
+let ``値ごとにカウントできる`` () =
+    let list =
+        createList
+            [ createValue 1 "1"
+              createValue 2 "2"
+              createValue 3 "Fizz"
+              createValue 6 "Fizz"
+              createValue 5 "Buzz" ]
+    let counts = list.CountByValue()
+    Assert.Equal(1, counts.["1"])
+    Assert.Equal(2, counts.["Fizz"])
+    Assert.Equal(1, counts.["Buzz"])
+```
+
+## 10.6 他言語との比較
+
+| 概念 | F# | Rust | Java |
+|------|-----|------|------|
+| パイプライン | `x \|> f` | — (メソッドチェーン) | — (Stream API) |
+| 部分適用 | `generate Standard` | クロージャで代替 | — |
+| 関数合成 | `f >> g` | — | `f.andThen(g)` |
+| 高階関数 | `List.map f` | `.iter().map(f)` | `.stream().map(f)` |
+| カリー化 | デフォルト | — | — |
+
+## 10.7 まとめ
+
+この章では以下を学びました。
+
+| 概念 | F# の記法 | 用途 |
+|------|----------|------|
+| パイプライン演算子 | `\|>` | 値を関数に渡す |
+| 関数合成演算子 | `>>` | 関数を結合して新しい関数を作成 |
+| カリー化 | デフォルト | 複数引数関数の段階的適用 |
+| 部分適用 | `generate Standard` | 引数の一部を固定した新しい関数 |
+| 高階関数 | `List.map`, `List.filter` | 関数を引数に取る関数 |
+
+次章では、**不変データ** と **コレクション処理** を深掘りし、F# のイミュータブル設計を学びます。