@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,246 @@
+# 第 2 章: 仮実装と三角測量
+
+## 2.1 はじめに
+
+前章では、FizzBuzz の仕様を TODO リストに分解し、最初のテストを仮実装で通しました。この章では、**三角測量** によってプログラムを一般化し、さらに FizzBuzz のコアロジックを実装していきます。
+
+**TODO リスト**:
+
+- [ ] 数を文字列にして返す
+  - [x] 1 を渡したら文字列 "1" を返す
+  - [ ] 2 を渡したら文字列 "2" を返す
+- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
+- [ ] 5 の倍数のときは「Buzz」と返す
+- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
+- [ ] 1 から 100 までの数
+- [ ] プリントする
+
+## 2.2 三角測量
+
+1 を渡したら文字列 "1" を返すようにできました。では、2 を渡したらどうなるでしょうか？
+
+### Red: 2 つ目のテストを書く
+
+```fsharp
+[<Fact>]
+let ``数を文字列にして返す_2を渡したら文字列2を返す`` () =
+    Assert.Equal("2", generate 2)
+```
+
+テストを実行します。
+
+```bash
+$ dotnet test
+  Assert.Equal() Failure
+  Expected: "2"
+  Actual:   "1"
+```
+
+テストが失敗しました。文字列 "1" しか返さないプログラムなのですから当然です。
+
+### Green: 一般化する
+
+数値を文字列に変換して返すように修正します。F# では `string` 関数で整数を文字列に変換できます。
+
+```fsharp
+let generate (number: int) : string =
+    string number
+```
+
+テストを実行します。
+
+```bash
+$ dotnet test
+  合計: 2、成功: 2、失敗: 0、スキップ: 0
+```
+
+テストが通りました。2 つ目のテストによって `generate` 関数の一般化を実現できました。このようなアプローチを **三角測量** と言います。
+
+> 三角測量
+>
+> テストから最も慎重に一般化を引き出すやり方はどのようなものだろうか——2 つ以上の例があるときだけ、一般化を行うようにしよう。
+>
+> — テスト駆動開発
+
+Rust では `number.to_string()` と書くところを、F# では `string number` という組み込み関数を使います。F# の `string` 関数は Rust の `Display` トレイトに相当する機能で、多くの型を文字列に変換できます。
+
+**TODO リスト**:
+
+- [x] 数を文字列にして返す
+  - [x] 1 を渡したら文字列 "1" を返す
+  - [x] 2 を渡したら文字列 "2" を返す
+- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
+- [ ] 5 の倍数のときは「Buzz」と返す
+- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
+- [ ] 1 から 100 までの数
+- [ ] プリントする
+
+## 2.3 3 の倍数 — Fizz
+
+次は「3 の倍数のときは数の代わりに Fizz と返す」に取り掛かります。
+
+### Red: 3 の倍数のテスト
+
+```fsharp
+[<Fact>]
+let ``三の倍数のときはFizzを返す`` () =
+    Assert.Equal("Fizz", generate 3)
+```
+
+```bash
+$ dotnet test
+  Assert.Equal() Failure
+  Expected: "Fizz"
+  Actual:   "3"
+```
+
+### Green: 明白な実装
+
+3 の倍数のときは "Fizz" を返すように実装します。F# では `%` 演算子で剰余を求め、`= 0` でゼロかどうかを判定します。
+
+```fsharp
+let generate (number: int) : string =
+    if number % 3 = 0 then "Fizz"
+    else string number
+```
+
+```bash
+$ dotnet test
+  合計: 3、成功: 3、失敗: 0、スキップ: 0
+```
+
+F# の `if/else` は式であり、常に値を返します。Rust の `if` 式や Kotlin の `when` 式と同様に、結果を変数にバインドしたりそのまま返したりできます。
+
+三角測量として 6 のテストも追加して確認します。
+
+```fsharp
+[<Fact>]
+let ``三の倍数のときはFizzを返す_6`` () =
+    Assert.Equal("Fizz", generate 6)
+```
+
+**TODO リスト**:
+
+- [x] 数を文字列にして返す
+- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
+- [ ] 5 の倍数のときは「Buzz」と返す
+- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
+- [ ] 1 から 100 までの数
+- [ ] プリントする
+
+## 2.4 5 の倍数 — Buzz
+
+### Red: 5 の倍数のテスト
+
+```fsharp
+[<Fact>]
+let ``五の倍数のときはBuzzを返す`` () =
+    Assert.Equal("Buzz", generate 5)
+```
+
+```bash
+$ dotnet test
+  Assert.Equal() Failure
+  Expected: "Buzz"
+  Actual:   "5"
+```
+
+### Green: Buzz の実装
+
+F# の `elif` キーワードで条件を追加します。
+
+```fsharp
+let generate (number: int) : string =
+    if number % 3 = 0 then "Fizz"
+    elif number % 5 = 0 then "Buzz"
+    else string number
+```
+
+```bash
+$ dotnet test
+  合計: 5、成功: 5、失敗: 0、スキップ: 0
+```
+
+F# では `else if` の代わりに `elif` を使います。Python の `elif` と同様の書き方です。
+
+**TODO リスト**:
+
+- [x] 数を文字列にして返す
+- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
+- [x] 5 の倍数のときは「Buzz」と返す
+- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
+- [ ] 1 から 100 までの数
+- [ ] プリントする
+
+## 2.5 15 の倍数 — FizzBuzz
+
+### Red: 15 の倍数のテスト
+
+```fsharp
+[<Fact>]
+let ``三と五の倍数のときはFizzBuzzを返す`` () =
+    Assert.Equal("FizzBuzz", generate 15)
+```
+
+```bash
+$ dotnet test
+  Assert.Equal() Failure
+  Expected: "FizzBuzz"
+  Actual:   "Fizz"
+```
+
+15 は 3 の倍数でもあるため、"Fizz" が返されてしまいました。3 と 5 の両方の倍数の判定を先に行う必要があります。
+
+### Green: FizzBuzz の実装
+
+```fsharp
+let generate (number: int) : string =
+    if number % 3 = 0 && number % 5 = 0 then "FizzBuzz"
+    elif number % 3 = 0 then "Fizz"
+    elif number % 5 = 0 then "Buzz"
+    else string number
+```
+
+```bash
+$ dotnet test
+  合計: 6、成功: 6、失敗: 0、スキップ: 0
+```
+
+F# の `&&` は論理 AND 演算子です。Rust や Java と同じ記号を使いますが、F# では等値比較に `=`（Rust は `==`）を使う点に注意してください。
+
+### パイプライン演算子の紹介
+
+ここで F# の特徴的な機能である **パイプライン演算子** `|>` を紹介します。パイプライン演算子は値を関数に渡すための構文で、Unix のパイプ `|` と同様にデータの流れを左から右に読めるようにします。
+
+```fsharp
+// 通常の関数呼び出し
+string 42
+
+// パイプライン演算子を使った呼び出し
+42 |> string
+```
+
+この段階ではまだ活用しませんが、次章以降で FizzBuzz のリファクタリングに活用します。
+
+**TODO リスト**:
+
+- [x] 数を文字列にして返す
+- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
+- [x] 5 の倍数のときは「Buzz」と返す
+- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
+- [ ] 1 から 100 までの数
+- [ ] プリントする
+
+## 2.6 まとめ
+
+この章では以下のことを学びました。
+
+- **三角測量** で 2 つ以上の例を使ってプログラムを一般化する手法
+- F# の `string` 関数による整数から文字列への変換
+- F# の `%` 演算子による剰余判定
+- F# の `if/elif/else` 式による条件分岐
+- F# の `&&` 演算子と `=` 演算子
+- **パイプライン演算子** `|>` の基本概念
+- Red-Green-Refactor サイクルを繰り返してコアロジックを段階的に構築する方法
+
+次章では、残りの TODO（リスト生成とプリント）を実装し、リファクタリングで「動作するきれいなコード」を目指します。

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

@@ -0,0 +1,218 @@
+# 第 3 章: 明白な実装とリファクタリング
+
+## 3.1 はじめに
+
+前章では、三角測量と明白な実装で FizzBuzz のコアロジックを完成させました。この章では、残りの TODO（リスト生成とプリント）を実装し、**match 式** と **パイプライン演算子** を活用してリファクタリングします。
+
+**TODO リスト**:
+
+- [x] 数を文字列にして返す
+- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
+- [x] 5 の倍数のときは「Buzz」と返す
+- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
+- [ ] 1 から 100 までの数
+- [ ] プリントする
+
+## 3.2 match 式によるリファクタリング
+
+テスト駆動開発の流れを確認しておきましょう。
+
+> 1. レッド：動作しない、おそらく最初のうちはコンパイルも通らないテストを 1 つ書く。
+> 2. グリーン：そのテストを迅速に動作させる。このステップでは罪を犯してもよい。
+> 3. リファクタリング：テストを通すために発生した重複をすべて除去する。
+>
+> レッド・グリーン・リファクタリング。それが TDD のマントラだ。
+>
+> — テスト駆動開発
+
+現在の `if/elif/else` による実装を、F# らしい **match 式** でリファクタリングします。
+
+### Before: if/elif/else
+
+```fsharp
+let generate (number: int) : string =
+    if number % 3 = 0 && number % 5 = 0 then "FizzBuzz"
+    elif number % 3 = 0 then "Fizz"
+    elif number % 5 = 0 then "Buzz"
+    else string number
+```
+
+### After: match 式（タプルパターン）
+
+```fsharp
+let generate (number: int) : string =
+    match (number % 3, number % 5) with
+    | (0, 0) -> "FizzBuzz"
+    | (0, _) -> "Fizz"
+    | (_, 0) -> "Buzz"
+    | _ -> string number
+```
+
+テストを実行して、リファクタリング後もすべて通ることを確認します。
+
+```bash
+$ dotnet test
+  合計: 6、成功: 6、失敗: 0、スキップ: 0
+```
+
+F# の `match` 式は Rust の `match` 式と非常によく似ています。タプル `(number % 3, number % 5)` に対してパターンを照合し、`_` はワイルドカード（任意の値にマッチ）です。Rust との違いは、矢印記号が `=>` ではなく `->` である点です。
+
+## 3.3 1 から 100 までのリスト生成
+
+### Red: リスト生成のテスト
+
+1 から 100 までの FizzBuzz の結果をリストとして返す関数をテストします。
+
+```fsharp
+[<Fact>]
+let ``一から百までのリストを生成する`` () =
+    let list = generateList 100
+    Assert.Equal(100, list.Length)
+    Assert.Equal("1", list.[0])
+    Assert.Equal("Fizz", list.[2])
+    Assert.Equal("Buzz", list.[4])
+    Assert.Equal("FizzBuzz", list.[14])
+```
+
+```bash
+$ dotnet test
+error FS0039: 値またはコンストラクター 'generateList' が定義されていません。
+```
+
+### Green: 明白な実装
+
+F# のリスト内包表記と `List.map` を使って実装します。
+
+```fsharp
+let generateList (count: int) : string list =
+    [ 1..count ] |> List.map generate
+```
+
+```bash
+$ dotnet test
+  合計: 7、成功: 7、失敗: 0、スキップ: 0
+```
+
+> 明白な実装
+>
+> シンプルな操作を実現するにはどうすればいいだろうか——そのまま実装しよう。
+>
+> — テスト駆動開発
+
+`[ 1..count ]` は F# の **リスト内包表記** で、1 から count までのリストを生成します。Rust の `(1..=count)` や Python の `range(1, count + 1)` に相当します。`|>` パイプライン演算子で `List.map generate` に渡し、各要素を `generate` 関数で変換します。
+
+**TODO リスト**:
+
+- [x] 数を文字列にして返す
+- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
+- [x] 5 の倍数のときは「Buzz」と返す
+- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
+- [x] 1 から 100 までの数
+- [ ] プリントする
+
+## 3.4 プリント機能
+
+### 学習用テスト
+
+プリント機能は、生成したリストの各要素を出力するものです。学習用テストとして、F# のリスト反復処理を確認します。
+
+> 学習用テスト
+>
+> 外部のソフトウェアのテストを書くべきだろうか——そのソフトウェアに対して新しいことを初めて行おうとした段階で書いてみよう。
+>
+> — テスト駆動開発
+
+F# では `List.iter` で各要素に対して副作用のある処理を実行できます。
+
+```fsharp
+[<Fact>]
+let ``リストの各要素を処理できる`` () =
+    let mutable result = []
+    [ "1"; "2"; "Fizz" ] |> List.iter (fun s -> result <- s :: result)
+    Assert.Equal(3, result.Length)
+```
+
+### Print 関数の実装
+
+```fsharp
+let printFizzBuzz (count: int) : unit =
+    generateList count |> List.iter (printfn "%s")
+```
+
+`printfn "%s"` は F# の書式付き出力関数です。`%s` は文字列のフォーマット指定子で、`printf` の F# 版です。戻り値の `unit` は Rust の `()` や Java の `void` に相当します。
+
+**TODO リスト**:
+
+- [x] 数を文字列にして返す
+- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
+- [x] 5 の倍数のときは「Buzz」と返す
+- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
+- [x] 1 から 100 までの数
+- [x] プリントする
+
+## 3.5 テストコードのリファクタリング
+
+テストを論理的なグループに構造化します。F# ではモジュールを使ってテストをグルーピングできます。
+
+```fsharp
+module Tests
+
+open Xunit
+open FizzBuzzFSharp.FizzBuzz
+
+module FizzBuzzRunnerTests =
+
+    [<Fact>]
+    let ``数を文字列にして返す_1を渡したら文字列1を返す`` () =
+        Assert.Equal("1", generate 1)
+
+    [<Fact>]
+    let ``数を文字列にして返す_2を渡したら文字列2を返す`` () =
+        Assert.Equal("2", generate 2)
+
+    [<Fact>]
+    let ``三の倍数のときはFizzを返す`` () =
+        Assert.Equal("Fizz", generate 3)
+
+    [<Fact>]
+    let ``五の倍数のときはBuzzを返す`` () =
+        Assert.Equal("Buzz", generate 5)
+
+    [<Fact>]
+    let ``三と五の倍数のときはFizzBuzzを返す`` () =
+        Assert.Equal("FizzBuzz", generate 15)
+
+    [<Fact>]
+    let ``一から百までのリストを生成する`` () =
+        let list = generateList 100
+        Assert.Equal(100, list.Length)
+        Assert.Equal("1", list.[0])
+        Assert.Equal("Fizz", list.[2])
+        Assert.Equal("Buzz", list.[4])
+        Assert.Equal("FizzBuzz", list.[14])
+```
+
+## 3.6 他言語との比較
+
+| 概念 | Java | Python | Rust | F# |
+|------|------|--------|------|-----|
+| テストフレームワーク | JUnit 5 | pytest | cargo test | xUnit |
+| テスト実行 | `./gradlew test` | `pytest` | `cargo test` | `dotnet test` |
+| 文字列変換 | `String.valueOf(n)` | `str(n)` | `n.to_string()` | `string n` |
+| 剰余判定 | `n % 3 == 0` | `n % 3 == 0` | `n % 3 == 0` | `n % 3 = 0` |
+| リスト生成 | `IntStream.rangeClosed` | `[f(n) for n in range]` | `(1..=n).map(f).collect()` | `[1..n] \|> List.map f` |
+| パターンマッチ | `switch`(Java 21+) | `match`(3.10+) | `match` | `match...with` |
+
+## 3.7 まとめ
+
+この章では以下のことを学びました。
+
+- **match 式** によるタプルパターンマッチング
+- **パイプライン演算子** `|>` によるデータ変換の連鎖
+- **リスト内包表記** `[1..count]` によるリスト生成
+- `List.map` と `List.iter` によるリスト操作
+- **明白な実装** でシンプルな操作をそのまま実装する手法
+- **リファクタリング** でテストモジュールを構造化する考え方
+- Red-Green-Refactor サイクルの完了
+
+第 1 部の 3 章を通じて、TDD の基本サイクル（仮実装 → 三角測量 → 明白な実装 → リファクタリング）を一通り体験しました。次の第 2 部では、開発環境の自動化（バージョン管理、パッケージ管理、CI/CD）に進みます。

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

@@ -0,0 +1,179 @@
+# 第 4 章: バージョン管理と Conventional Commits
+
+## 4.1 はじめに
+
+前章までで、TDD の基本サイクルを通じて FizzBuzz プログラムを完成させました。この章からは「動作するきれいなコード」を書き続けるために必要な **ソフトウェア開発の三種の神器** を整備していきます。
+
+> 今日のソフトウェア開発の世界において絶対になければならない 3 つの技術的な柱があります。三本柱と言ったり、三種の神器と言ったりしていますが、それらは
+>
+> - バージョン管理
+> - テスティング
+> - 自動化
+>
+> の 3 つです。
+>
+> — 和田卓人
+
+**バージョン管理** と **テスティング** に関しては第 1 部で触れました。本章ではバージョン管理をさらに深掘りし、**コミットメッセージの規約** について解説します。
+
+## 4.2 コミットメッセージの重要性
+
+これまでの作業では、区切りごとにリポジトリにコミットしてきました。しかし、コミットメッセージの書き方に一貫性がないと、後からプロジェクトの履歴を追うのが難しくなります。
+
+チーム開発では特に、誰がいつ何のためにコードを変更したのかを明確にすることが重要です。そこで役立つのが **Conventional Commits** です。
+
+## 4.3 Conventional Commits
+
+本プロジェクトでは [Angular ルール](https://github.com/angular/angular.js/blob/master/DEVELOPERS.md#type) に基づいた **Conventional Commits** の書式を採用します。
+
+### コミットメッセージのフォーマット
+
+```
+<タイプ>(<スコープ>): <タイトル>
+<空行>
+<ボディ>
+<空行>
+<フッタ>
+```
+
+### タイプの種類
+
+| タイプ | 説明 | 例 |
+|--------|------|-----|
+| `feat` | 新機能の追加 | `feat: FizzBuzz のコアロジックを実装` |
+| `fix` | バグの修正 | `fix: 15 の倍数の判定順序を修正` |
+| `refactor` | リファクタリング | `refactor: match 式でパターンマッチに変更` |
+| `test` | テストの追加・修正 | `test: 三角測量のテストケースを追加` |
+| `docs` | ドキュメントの変更 | `docs: README にセットアップ手順を追加` |
+| `chore` | ビルド・ツールの変更 | `chore: Cake ビルドスクリプトを追加` |
+| `style` | コードスタイルの変更 | `style: Fantomas で自動フォーマット` |
+
+### F# プロジェクトでの例
+
+```bash
+# テスト追加
+$ git commit -m 'test: 数を文字列にして返す'
+
+# 機能実装
+$ git commit -m 'feat: generate 関数で match 式による FizzBuzz 判定を実装'
+
+# リファクタリング
+$ git commit -m 'refactor: パイプライン演算子でリスト生成を簡潔に記述'
+```
+
+## 4.4 Git の基本操作
+
+### リポジトリの初期化
+
+```bash
+# プロジェクトディレクトリで Git リポジトリを初期化
+$ git init
+
+# .gitignore を作成
+$ echo "bin/
+obj/
+.vs/
+*.user
+coverage/
+test-results/" > .gitignore
+
+# 初期コミット
+$ git add .
+$ git commit -m "feat: initial commit"
+```
+
+### 基本的なワークフロー
+
+```bash
+# 変更内容を確認
+$ git status
+
+# 特定のファイルをステージング
+$ git add src/Library.fs tests/Tests.fs
+
+# コミット
+$ git commit -m 'feat: generate 関数で FizzBuzz 判定を実装'
+
+# 履歴の確認
+$ git log --oneline
+```
+
+### 意味のある単位でのコミット
+
+TDD の各フェーズでコミットすることで、変更の意図が明確になります。
+
+```bash
+# Red フェーズ: テストの追加
+$ git add tests/Tests.fs
+$ git commit -m 'test: 三の倍数で Fizz を返すテストを追加'
+
+# Green フェーズ: 実装
+$ git add src/Library.fs
+$ git commit -m 'feat: 三の倍数で Fizz を返す実装を追加'
+
+# Refactor フェーズ: リファクタリング
+$ git add src/Library.fs
+$ git commit -m 'refactor: match 式でパターンマッチに変更'
+```
+
+## 4.5 Git フロー
+
+### ブランチ戦略
+
+| ブランチ | 用途 |
+|---------|------|
+| `main` | リリース可能な安定版 |
+| `develop` | 開発中の最新コード |
+| `feature/*` | 機能開発用ブランチ |
+
+### 作業の流れ
+
+1. `develop` ブランチから作業を開始
+2. TDD サイクル（Red → Green → Refactor）を実行
+3. Conventional Commits の書式でコミット
+4. テストが通ることを確認してプッシュ
+
+### Feature Branch ワークフロー
+
+```bash
+# 新機能開発用のブランチを作成
+$ git checkout -b feature/add-fizzbuzz-type
+
+# 開発作業（TDD サイクル）
+# ... コーディング ...
+
+# 変更をコミット
+$ git add .
+$ git commit -m "feat: FizzBuzzType 判別共用体を追加"
+
+# develop ブランチに統合
+$ git checkout develop
+$ git merge feature/add-fizzbuzz-type
+$ git branch -d feature/add-fizzbuzz-type
+```
+
+### F# プロジェクトでの .gitignore
+
+.NET プロジェクトでは以下のファイルをバージョン管理から除外します。
+
+```
+bin/
+obj/
+.vs/
+*.user
+coverage/
+test-results/
+```
+
+## 4.6 まとめ
+
+この章では以下を学びました。
+
+| 概念 | 説明 |
+|------|------|
+| Conventional Commits | コミットメッセージの標準的な書式 |
+| タイプ | feat, fix, refactor, test, docs, chore, style |
+| スコープ | 変更の影響範囲（任意） |
+| Git フロー | main / develop / feature ブランチ戦略 |
+
+次章では、NuGet によるパッケージ管理と Fantomas による静的解析を導入します。