@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,212 @@
+# 第 11 章: 不変データとコレクション処理
+
+## 11.1 はじめに
+
+前章ではパイプライン演算子と関数合成を学びました。この章では F# の **不変データ** の考え方と、**List モジュール** / **Seq モジュール** によるコレクション処理を深掘りします。
+
+## 11.2 F# の不変性
+
+F# では変数はデフォルトで **不変（immutable）** です。
+
+```fsharp
+let x = 5        // 不変（デフォルト）
+let mutable y = 10  // 可変（明示的）
+```
+
+Rust と同様に、不変がデフォルトの設計です。Rust では `let` が不変、`let mut` が可変ですが、F# では `let` が不変、`let mutable` が可変です。
+
+### レコード型の不変性
+
+FizzBuzzValue レコード型はデフォルトで不変です。
+
+```fsharp
+let value = createValue 3 "Fizz"
+// value.Value <- "Buzz"  // コンパイルエラー: レコードフィールドは変更できない
+
+// 新しい値を作成する場合は with 式を使う
+let newValue = { value with Value = "Buzz" }
+Assert.Equal("Fizz", value.Value)    // 元の値は変わらない
+Assert.Equal("Buzz", newValue.Value) // 新しい値が作成される
+```
+
+### FizzBuzzList の不変設計
+
+`Add` メソッドは元のリストを変更せず、新しいリストを返します。
+
+```fsharp
+[<Fact>]
+let ``値を追加できる`` () =
+    let list = emptyList
+    let newList = list.Add(createValue 1 "1")
+    Assert.Equal(1, newList.Count)
+    Assert.Equal(0, list.Count)  // 元のリストは不変
+```
+
+## 11.3 List モジュール
+
+F# の `List` モジュールはイミュータブルなリンクドリストを操作する関数群を提供します。
+
+### List.map — 要素の変換
+
+```fsharp
+// 各 FizzBuzzValue の Value フィールドを取得
+let stringValues =
+    fizzBuzzList.Values
+    |> List.map (fun v -> v.Value)
+// ["1"; "2"; "Fizz"; "4"; "Buzz"; ...]
+```
+
+### List.filter — 要素の選別
+
+```fsharp
+// Fizz の値だけを抽出
+let fizzValues =
+    fizzBuzzList.Values
+    |> List.filter (fun v -> v.Value = "Fizz")
+```
+
+### List.fold — 集約
+
+```fsharp
+// すべての Value を改行区切りで連結
+let joined =
+    fizzBuzzList.Values
+    |> List.map (fun v -> v.Value)
+    |> List.fold (fun acc v ->
+        if acc = "" then v
+        else acc + "\n" + v) ""
+```
+
+`List.fold` は Rust の `.fold()` や Java の `Stream.reduce()` に相当します。初期値と累積関数を受け取り、リストの各要素を順に処理します。
+
+### List.groupBy — グルーピング
+
+```fsharp
+// Value でグルーピングしてカウント
+let counts =
+    fizzBuzzList.Values
+    |> List.groupBy (fun v -> v.Value)
+    |> List.map (fun (key, group) -> (key, List.length group))
+    |> Map.ofList
+```
+
+### List.tryFind — 最初の一致要素
+
+```fsharp
+let firstFizz =
+    fizzBuzzList.Values
+    |> List.tryFind (fun v -> v.Value = "Fizz")
+
+match firstFizz with
+| Some value -> printfn "Found: %s" (value.ToString())
+| None -> printfn "Not found"
+```
+
+`List.tryFind` は `Option<'T>` を返します。Rust の `.find()` が `Option<T>` を返すのと同様です。
+
+## 11.4 Seq モジュール
+
+`Seq` モジュールは **遅延評価** されるシーケンスを操作します。
+
+```fsharp
+// Seq は遅延評価（必要な分だけ計算）
+let firstFiveFizzBuzz =
+    Seq.initInfinite (fun i -> generate Standard (i + 1))
+    |> Seq.map (fun v -> v.Value)
+    |> Seq.take 5
+    |> Seq.toList
+// ["1"; "2"; "Fizz"; "4"; "Buzz"]
+```
+
+### List と Seq の使い分け
+
+| 特徴 | List | Seq |
+|------|------|-----|
+| 評価方式 | 即時評価 | 遅延評価 |
+| メモリ使用 | 全要素をメモリに保持 | 必要な分だけ計算 |
+| 無限列 | 不可 | 可能（Seq.initInfinite） |
+| パフォーマンス | 小〜中サイズに最適 | 大量データに最適 |
+| 用途 | 一般的なコレクション操作 | ストリーム処理、大量データ |
+
+Rust のイテレータも遅延評価ですが、F# では `List`（即時）と `Seq`（遅延）を明示的に使い分けます。
+
+## 11.5 FizzBuzzList のイミュータブル設計
+
+### パイプラインによるコレクション操作
+
+FizzBuzzList にコレクション操作メソッドを追加します。
+
+```fsharp
+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 ] }
+
+member this.AddRange(values: FizzBuzzValue list) =
+    { Values = this.Values @ values }
+```
+
+すべてのメソッドが **新しい値を返す** 設計です。元のリストは変更されません。
+
+### テストで確認
+
+```fsharp
+[<Fact>]
+let ``文字列リストに変換できる`` () =
+    let list =
+        createList
+            [ createValue 1 "1"
+              createValue 3 "Fizz"
+              createValue 5 "Buzz" ]
+    let strings = list.ToStringValues()
+    Assert.Equal<string list>([ "1"; "Fizz"; "Buzz" ], strings)
+
+[<Fact>]
+let ``最初の一致する値を取得できる`` () =
+    let list =
+        createList
+            [ createValue 1 "1"
+              createValue 3 "Fizz"
+              createValue 6 "Fizz" ]
+    let found = list.FindFirst(fun v -> v.Value = "Fizz")
+    Assert.True(found.IsSome)
+    Assert.Equal(3, found.Value.Number)
+
+[<Fact>]
+let ``一致する値がない場合はNoneを返す`` () =
+    let list =
+        createList [ createValue 1 "1"; createValue 2 "2" ]
+    let found = list.FindFirst(fun v -> v.Value = "Fizz")
+    Assert.True(found.IsNone)
+```
+
+## 11.6 他言語との比較
+
+| 概念 | F# | Rust | Java |
+|------|-----|------|------|
+| 不変デフォルト | `let x = 5` | `let x = 5` | `final` で明示 |
+| パイプライン | `\|> List.filter f \|> List.map g` | `.iter().filter(f).map(g)` | `.stream().filter(f).map(g)` |
+| fold | `List.fold f init list` | `.fold(init, f)` | `.reduce(init, f)` |
+| 遅延評価 | `Seq` モジュール | イテレータ（デフォルト遅延） | `Stream`（デフォルト遅延） |
+| Option | `Some v / None` | `Some(v) / None` | `Optional.of(v) / empty()` |
+
+## 11.7 まとめ
+
+この章では以下を学びました。
+
+| 概念 | F# の実現方法 |
+|------|---------------|
+| 不変性 | `let` バインディング、レコード型 |
+| コピー | `with` 式によるレコードの部分更新 |
+| List モジュール | map, filter, fold, groupBy, tryFind |
+| Seq モジュール | 遅延評価によるストリーム処理 |
+| イミュータブル設計 | 操作は常に新しい値を返す |
+
+次章では、**Option 型** と **Result 型** を使ったエラーハンドリングと型安全性を学びます。

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

@@ -0,0 +1,215 @@
+# 第 12 章: エラーハンドリングと型安全性
+
+## 12.1 はじめに
+
+前章では不変データとコレクション処理を学びました。この最終章では、F# の **Option 型** と **Result 型** を使ったエラーハンドリング、そして **計算式（Computation Expressions）** による型安全な設計を学びます。
+
+## 12.2 Option 型
+
+F# には `null` を直接扱う代わりに **Option 型** を使います。値が存在しない可能性を型で明示します。
+
+```fsharp
+// Option 型の定義（組み込み）
+// type Option<'T> = Some of 'T | None
+```
+
+### FizzBuzzList での活用
+
+`FindFirst` メソッドは `Option<FizzBuzzValue>` を返します。
+
+```fsharp
+member this.FindFirst(predicate: FizzBuzzValue -> bool) =
+    this.Values |> List.tryFind predicate
+```
+
+### パターンマッチによる処理
+
+```fsharp
+let list =
+    createList
+        [ createValue 1 "1"
+          createValue 3 "Fizz"
+          createValue 5 "Buzz" ]
+
+match list.FindFirst(fun v -> v.Value = "Fizz") with
+| Some value -> printfn "Found: %d:%s" value.Number value.Value
+| None -> printfn "Not found"
+```
+
+### Option モジュールの活用
+
+```fsharp
+// Option.map: Some の場合のみ変換
+let fizzNumber =
+    list.FindFirst(fun v -> v.Value = "Fizz")
+    |> Option.map (fun v -> v.Number)
+// Some 3
+
+// Option.defaultValue: None の場合のデフォルト値
+let numberOrDefault =
+    list.FindFirst(fun v -> v.Value = "Missing")
+    |> Option.map (fun v -> v.Number)
+    |> Option.defaultValue 0
+// 0
+
+// Option.bind: Some の場合のみ次の Option を返す関数を適用
+let findAndFilter =
+    list.FindFirst(fun v -> v.Value = "Fizz")
+    |> Option.bind (fun v ->
+        if v.Number > 2 then Some v
+        else None)
+```
+
+## 12.3 Result 型
+
+**Result 型** は操作の成功/失敗を型で明示します。例外をスローする代わりに、`Ok` または `Error` を返します。
+
+```fsharp
+// Result 型の定義（組み込み）
+// type Result<'T, 'TError> = Ok of 'T | Error of 'TError
+```
+
+### FizzBuzz でのエラーハンドリング
+
+不正な入力値に対するバリデーションを Result 型で表現します。
+
+```fsharp
+let validateNumber (number: int) : Result<int, string> =
+    if number <= 0 then Error "数値は正の整数でなければなりません"
+    elif number > 1000 then Error "数値は1000以下でなければなりません"
+    else Ok number
+
+let safeGenerate (fizzBuzzType: FizzBuzzType) (number: int) : Result<FizzBuzzValue, string> =
+    number
+    |> validateNumber
+    |> Result.map (generate fizzBuzzType)
+```
+
+### テストで確認
+
+```fsharp
+[<Fact>]
+let ``正の整数でバリデーション成功`` () =
+    let result = validateNumber 5
+    match result with
+    | Ok n -> Assert.Equal(5, n)
+    | Error _ -> Assert.Fail("Expected Ok")
+
+[<Fact>]
+let ``ゼロ以下でバリデーション失敗`` () =
+    let result = validateNumber 0
+    match result with
+    | Ok _ -> Assert.Fail("Expected Error")
+    | Error msg -> Assert.Equal("数値は正の整数でなければなりません", msg)
+
+[<Fact>]
+let ``safeGenerateで安全にFizzBuzzを生成`` () =
+    let result = safeGenerate Standard 15
+    match result with
+    | Ok value -> Assert.Equal("FizzBuzz", value.Value)
+    | Error _ -> Assert.Fail("Expected Ok")
+```
+
+### Result モジュールの活用
+
+```fsharp
+// Result.map: Ok の場合のみ変換
+let stringResult =
+    safeGenerate Standard 15
+    |> Result.map (fun v -> v.Value)
+// Ok "FizzBuzz"
+
+// Result.bind: Ok の場合のみ次の Result を返す関数を適用
+let chainedResult =
+    validateNumber 15
+    |> Result.bind (fun n ->
+        if n % 3 = 0 || n % 5 = 0 then Ok n
+        else Error "FizzBuzz に該当しない数値です")
+    |> Result.map (generate Standard)
+```
+
+## 12.4 計算式（Computation Expressions）
+
+F# の **計算式** は、モナド的な処理を直感的に記述するための構文です。`let!` を使って Result や Option のチェーンを読みやすく書けます。
+
+### result 計算式ビルダー
+
+```fsharp
+type ResultBuilder() =
+    member _.Bind(result, f) =
+        match result with
+        | Ok value -> f value
+        | Error e -> Error e
+    member _.Return(value) = Ok value
+    member _.ReturnFrom(result) = result
+
+let result = ResultBuilder()
+```
+
+### 使用例
+
+```fsharp
+let processNumber (fizzBuzzType: FizzBuzzType) (input: int) =
+    result {
+        let! validNumber = validateNumber input
+        let fizzBuzzValue = generate fizzBuzzType validNumber
+        return fizzBuzzValue.Value
+    }
+
+// テスト
+[<Fact>]
+let ``計算式で安全に処理できる`` () =
+    match processNumber Standard 15 with
+    | Ok value -> Assert.Equal("FizzBuzz", value)
+    | Error _ -> Assert.Fail("Expected Ok")
+
+[<Fact>]
+let ``計算式でエラーが伝播する`` () =
+    match processNumber Standard 0 with
+    | Ok _ -> Assert.Fail("Expected Error")
+    | Error msg -> Assert.Equal("数値は正の整数でなければなりません", msg)
+```
+
+計算式の `let!` は Rust の `?` 演算子に相当します。`Error` が発生した時点で処理を中断し、エラーを伝播します。
+
+## 12.5 Option と Result の使い分け
+
+| 型 | 用途 | 例 |
+|-----|------|-----|
+| `Option<'T>` | 値の有無を表現 | 検索結果が見つからない場合 |
+| `Result<'T, 'E>` | 成功/失敗とエラー情報を表現 | バリデーション失敗時にエラーメッセージを返す |
+
+```fsharp
+// Option: 見つからないだけ（エラー情報不要）
+let found = list.FindFirst(fun v -> v.Value = "Fizz")
+
+// Result: なぜ失敗したかの情報が必要
+let validated = validateNumber -1
+```
+
+## 12.6 他言語との比較
+
+| 概念 | F# | Rust | Java |
+|------|-----|------|------|
+| エラーハンドリング | `Result<'T, 'E>` | `Result<T, E>` | `try-catch` |
+| null 安全 | `Option<'T>` | `Option<T>` | `Optional<T>` |
+| エラー伝播 | 計算式 `let!` | `?` 演算子 | `throws` |
+| パターンマッチ | `match...with` | `match` | `switch`(Java 21+) |
+| モナド構文 | 計算式 | — | — |
+
+F# の計算式は Haskell の `do` 記法に相当する機能で、Rust にはない F# 独自の強力な機能です。
+
+## 12.7 まとめ
+
+この章では以下を学びました。
+
+| 概念 | F# の実現方法 |
+|------|---------------|
+| Option 型 | `Some v / None` + パターンマッチ |
+| Result 型 | `Ok v / Error e` + パターンマッチ |
+| Option モジュール | map, bind, defaultValue |
+| Result モジュール | map, bind |
+| 計算式 | `result { let! ... return ... }` |
+| エラー伝播 | `let!` による自動伝播 |
+
+全 12 章を通じて、F# の TDD 基本サイクル、開発環境の自動化、関数型アプローチによる設計、高度な関数型プログラミングを一通り学びました。F# のパイプライン演算子、判別共用体、パターンマッチ、不変データ、Result/Option は、安全で堅牢なソフトウェアを構築するための強力な基盤です。

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

@@ -0,0 +1,71 @@
+# テスト駆動開発から始める F# 入門
+
+## 概要
+
+FizzBuzz 問題を題材に、テスト駆動開発（TDD）の基本サイクルから、開発環境の整備、関数型アプローチによる設計、F# の高度な関数型プログラミングまで、段階的に学びます。
+
+## 対象読者
+
+- F# や関数型プログラミングに興味があるプログラミング学習者
+- TDD を体験してみたい開発者
+- .NET エコシステムで関数型プログラミングを始めたい方
+
+## 前提条件
+
+- .NET 8.0 SDK がインストールされていること
+- Nix 環境推奨: `nix develop .#dotnet`
+
+## F# の特徴
+
+| 特徴 | 説明 |
+|------|------|
+| 不変性がデフォルト | `let` バインディングは不変、`mutable` で明示的に変更可能に |
+| パイプライン演算子 | `\|>` でデータ変換を読みやすく連鎖 |
+| 判別共用体 | 代数的データ型による型安全な分岐 |
+| パターンマッチ | 網羅的なパターンマッチングによる分岐 |
+| レコード型 | 不変のデータ構造を簡潔に定義 |
+| 型推論 | Hindley-Milner 型推論による簡潔なコード |
+
+## 開発ツール
+
+| ツール | 用途 |
+|--------|------|
+| dotnet CLI | ビルド・テスト・パッケージ管理 |
+| xUnit | テスティングフレームワーク |
+| NuGet | パッケージマネージャ |
+| Fantomas | F# コードフォーマッター |
+| Cake | タスクランナー（C# DSL） |
+
+## 記事一覧
+
+### 第 1 部: TDD の基本サイクル
+
+| 章 | タイトル | 内容 |
+|----|---------|------|
+| [第 1 章](chapter01.md) | TODO リストと最初のテスト | テストファースト、Red-Green の基本 |
+| [第 2 章](chapter02.md) | 仮実装と三角測量 | 仮実装から本実装への段階的アプローチ |
+| [第 3 章](chapter03.md) | 明白な実装とリファクタリング | パイプライン演算子によるリファクタリング |
+
+### 第 2 部: 開発環境と自動化
+
+| 章 | タイトル | 内容 |
+|----|---------|------|
+| [第 4 章](chapter04.md) | バージョン管理と Conventional Commits | Git と Conventional Commits |
+| [第 5 章](chapter05.md) | パッケージ管理と静的解析 | NuGet、Fantomas |
+| [第 6 章](chapter06.md) | タスクランナーと CI/CD | Cake、GitHub Actions |
+
+### 第 3 部: 関数型アプローチによる設計
+
+| 章 | タイトル | 内容 |
+|----|---------|------|
+| [第 7 章](chapter07.md) | レコード型とモジュールによるカプセル化 | レコード型、モジュール、アクセス制御 |
+| [第 8 章](chapter08.md) | 判別共用体とパターンマッチ | 代数的データ型、網羅的パターンマッチ |
+| [第 9 章](chapter09.md) | モジュール設計と型による設計 | 型駆動設計、モジュール分割 |
+
+### 第 4 部: 関数型プログラミング
+
+| 章 | タイトル | 内容 |
+|----|---------|------|
+| [第 10 章](chapter10.md) | 高階関数と関数合成 | パイプライン演算子、部分適用、カリー化 |
+| [第 11 章](chapter11.md) | 不変データとコレクション処理 | List / Seq モジュール、fold / map |
+| [第 12 章](chapter12.md) | エラーハンドリングと型安全性 | Result / Option、計算式 |