@k2works/claude-code-booster 6.1.0 → 6.3.0

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

@@ -1,199 +0,0 @@
----
-type: Article
-title: "第 6 章: タスクランナーと CI/CD"
-description: "前章では NuGet によるパッケージ管理と Fantomas によるコードフォーマットを導入しました。"
-tags: [article, getting-start-tdd, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 6 章: タスクランナーと CI/CD
-
-## 6.1 はじめに
-
-前章では NuGet によるパッケージ管理と Fantomas によるコードフォーマットを導入しました。テストの実行、静的解析、フォーマットチェックと、様々なコマンドを使えるようになりましたが、毎回それぞれのコマンドを覚えて実行するのは面倒です。
-
-この章では **タスクランナー** を使ってこれらのタスクをまとめて実行できるようにし、さらに **CI/CD** パイプラインを構築します。
-
-## 6.2 Cake によるタスク管理
-
-### Cake とは
-
-> Cake（C# Make）は C# で記述できるクロスプラットフォームのビルド自動化ツールです。タスクの定義、依存関係の管理、実行をスクリプトで記述します。
-
-Ruby の Rake、Java の Gradle、Node の npm scripts、Rust の Makefile に相当します。F# プロジェクトでは Cake が広く使われています。
-
-### Cake ビルドスクリプトの定義
-
-```csharp
-// build.cake
-var target = Argument("target", "Default");
-var configuration = Argument("configuration", "Release");
-
-Task("Clean")
-    .Does(() =>
-{
-    CleanDirectory("./src/bin");
-    CleanDirectory("./src/obj");
-    CleanDirectory("./tests/bin");
-    CleanDirectory("./tests/obj");
-});
-
-Task("Build")
-    .IsDependentOn("Clean")
-    .Does(() =>
-{
-    DotNetBuild("./FizzBuzzFSharp.sln", new DotNetBuildSettings
-    {
-        Configuration = configuration
-    });
-});
-
-Task("Format")
-    .Does(() =>
-{
-    StartProcess("dotnet", "fantomas ./src --recurse");
-    StartProcess("dotnet", "fantomas ./tests --recurse");
-});
-
-Task("Test")
-    .IsDependentOn("Build")
-    .Does(() =>
-{
-    DotNetTest("./tests/FizzBuzzFSharpTest.fsproj", new DotNetTestSettings
-    {
-        Configuration = configuration,
-        NoBuild = true
-    });
-});
-
-Task("All")
-    .IsDependentOn("Clean")
-    .IsDependentOn("Format")
-    .IsDependentOn("Build")
-    .IsDependentOn("Test");
-
-Task("Default")
-    .IsDependentOn("All");
-
-RunTarget(target);
-```
-
-### 主要なタスク
-
-| タスク | コマンド | 説明 |
-|--------|---------|------|
-| `dotnet cake` | 全タスク実行 | Clean → Format → Build → Test |
-| `dotnet cake --target=Test` | テスト実行 | Build → Test |
-| `dotnet cake --target=Format` | フォーマット | Fantomas 実行 |
-| `dotnet cake --target=Clean` | クリーン | ビルド成果物の削除 |
-
-### 実行例
-
-```bash
-# 全チェック実行
-$ dotnet cake
-========================================
-Clean
-========================================
-Build
-========================================
-Format
-========================================
-Test
-  合計: 7、成功: 7、失敗: 0、スキップ: 0
-========================================
-Task Duration
---------------------------------------------------
-Clean    00:00:00.1234567
-Build    00:00:02.3456789
-Format   00:00:01.2345678
-Test     00:00:03.4567890
---------------------------------------------------
-Total:   00:00:07.1604924
-```
-
-## 6.3 GitHub Actions による CI/CD
-
-### CI/CD とは
-
-> CI/CD（Continuous Integration / Continuous Delivery）は、コードの変更を自動的にビルド、テスト、デプロイするプラクティスです。
-
-### ワークフローの定義
-
-`.github/workflows/fsharp-ci.yml` にワークフローを定義します。
-
-```yaml
-name: F# CI
-
-on:
-  push:
-    branches: [main, develop]
-    paths:
-      - "apps/dotnet/FizzBuzzFSharp/**"
-      - "apps/dotnet/FizzBuzzFSharpTest/**"
-      - ".github/workflows/fsharp-ci.yml"
-  pull_request:
-    branches: [main]
-    paths:
-      - "apps/dotnet/FizzBuzzFSharp/**"
-      - "apps/dotnet/FizzBuzzFSharpTest/**"
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v4
-
-      - name: Setup .NET
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 8.0.x
-
-      - name: Restore dependencies
-        run: dotnet restore
-        working-directory: apps/dotnet
-
-      - name: Build
-        run: dotnet build --no-restore
-        working-directory: apps/dotnet
-
-      - name: Run tests
-        run: dotnet test --no-build
-        working-directory: apps/dotnet
-```
-
-### CI パイプラインの流れ
-
-```
-Push / PR → Restore → Build → Test → 結果通知
-```
-
-## 6.4 他言語との比較
-
-| 言語 | タスクランナー | CI ツール | テスト | フォーマット |
-|------|-------------|----------|--------|------------|
-| F# | Cake | GitHub Actions | xUnit | Fantomas |
-| Rust | Makefile | GitHub Actions | cargo test | rustfmt |
-| Go | Makefile | GitHub Actions | go test | gofmt |
-| Java | Gradle | GitHub Actions | JUnit | Checkstyle |
-| Python | tox | GitHub Actions | pytest | Ruff |
-| Node | npm scripts | GitHub Actions | Vitest | Prettier |
-
-## 6.5 まとめ
-
-この章では以下を実現しました。
-
-| 項目 | 内容 |
-|------|------|
-| Cake | Clean / Format / Build / Test タスクを定義 |
-| `dotnet cake` | フォーマット → ビルド → テストを一括実行 |
-| GitHub Actions | push / PR 時に自動で CI を実行 |
-| .NET SDK 統合 | CI でも同じ dotnet コマンドを使用し環境を統一 |
-
-第 2 部を通じて、ソフトウェア開発の三種の神器（バージョン管理、テスティング、自動化）を F# の開発環境に整備しました。次の第 3 部では、F# の関数型アプローチによる設計（レコード型、判別共用体、モジュール分割）に進みます。

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

@@ -1,170 +0,0 @@
----
-type: Article
-title: "第 7 章: レコード型とモジュールによるカプセル化"
-description: "第 1 部では手続き型の FizzBuzz プログラムを TDD で構築しました。"
-tags: [article, getting-start-tdd, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 7 章: レコード型とモジュールによるカプセル化
-
-## 7.1 はじめに
-
-第 1 部では手続き型の FizzBuzz プログラムを TDD で構築しました。この章からは **F# の関数型アプローチ** による設計を導入していきます。まず **レコード型** と **モジュール** によるカプセル化を実現します。
-
-## 7.2 手続き型コードの課題
-
-第 1 部で作成した `generate` 関数は手続き型プログラミングの典型例です。
-
-```fsharp
-let generate (number: int) : string =
-    match (number % 3, number % 5) with
-    | (0, 0) -> "FizzBuzz"
-    | (0, _) -> "Fizz"
-    | (_, 0) -> "Buzz"
-    | _ -> string number
-```
-
-この設計の課題は、数値と変換結果の関係がプリミティブ型（`int` と `string`）で表現されており、ドメインの意味が失われていることです。
-
-## 7.3 レコード型による値オブジェクト
-
-### FizzBuzzValue レコード型
-
-数値と FizzBuzz の結果をまとめたレコード型を作成します。
-
-```fsharp
-type FizzBuzzValue =
-    { Number: int
-      Value: string }
-
-    override this.ToString() = sprintf "%d:%s" this.Number this.Value
-```
-
-### テストを書く
-
-```fsharp
-[<Fact>]
-let ``値を保持する`` () =
-    let value = createValue 1 "1"
-    Assert.Equal(1, value.Number)
-    Assert.Equal("1", value.Value)
-
-[<Fact>]
-let ``同じ値のレコードは等しい`` () =
-    let value1 = createValue 1 "1"
-    let value2 = createValue 1 "1"
-    Assert.Equal(value1, value2)
-
-[<Fact>]
-let ``ToStringはNumber_Colon_Value形式`` () =
-    let value = createValue 3 "Fizz"
-    Assert.Equal("3:Fizz", value.ToString())
-```
-
-### createValue 関数の実装
-
-```fsharp
-let createValue number value = { Number = number; Value = value }
-```
-
-```bash
-$ dotnet test
-  合計: 10、成功: 10、失敗: 0、スキップ: 0
-```
-
-F# のレコード型は **構造的等価性** を持ちます。つまり、フィールドの値が同じであれば 2 つのレコードは等しいと判定されます。Rust では `#[derive(PartialEq)]` が必要ですが、F# のレコード型ではデフォルトで構造的等価性が提供されます。
-
-### レコード型の特徴
-
-| 特徴 | F# レコード型 | Rust struct | Java class |
-|------|-------------|-------------|------------|
-| 不変性 | デフォルト不変 | デフォルト不変 | 明示的に `final` |
-| 等価性 | 構造的（自動） | `#[derive(PartialEq)]` | `equals()` 手動実装 |
-| コピー | `{ record with Field = newValue }` | `.clone()` | コンストラクタで新規作成 |
-| パターンマッチ | 対応 | 対応 | Java 21+ で対応 |
-
-## 7.4 モジュールによるアクセス制御
-
-### Domain モジュールの作成
-
-F# では `module` でコードをグルーピングし、`private` でアクセスを制御します。
-
-```fsharp
-namespace FizzBuzzFSharp
-
-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 }
-
-    let private isFizz number = number % 3 = 0
-    let private isBuzz number = number % 5 = 0
-    let private isFizzBuzz number = isFizz number && isBuzz number
-```
-
-`private` キーワードで修飾された関数はモジュール外からアクセスできません。Rust の `pub`/非公開 や Java の `private` に相当します。
-
-### generate 関数の更新
-
-`generate` 関数を Domain モジュール内に移動し、`FizzBuzzValue` を返すように変更します。
-
-```fsharp
-let generate (number: int) : FizzBuzzValue =
-    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)
-```
-
-### テストの更新
-
-```fsharp
-[<Fact>]
-let ``Standard_数を文字列にして返す`` () =
-    let result = Domain.generate 1
-    Assert.Equal("1", result.Value)
-
-[<Fact>]
-let ``Standard_三の倍数のときはFizzを返す`` () =
-    let result = Domain.generate 3
-    Assert.Equal("Fizz", result.Value)
-```
-
-## 7.5 F# のモジュールシステム
-
-F# のモジュールシステムは `namespace` と `module` の 2 つの構造で構成されます。
-
-```fsharp
-namespace FizzBuzzFSharp    // 名前空間
-
-module Domain =              // モジュール（値と関数を含む）
-    let createValue ...      // 公開関数
-    let private isFizz ...   // 非公開関数
-```
-
-| 構造 | 用途 | Rust の対応 |
-|------|------|-----------|
-| `namespace` | 型のグルーピング | `mod`（ファイルレベル） |
-| `module` | 関数と値のグルーピング | `mod`（内部モジュール） |
-| `private` | アクセス制限 | デフォルト非公開 |
-| `internal` | アセンブリ内公開 | `pub(crate)` |
-
-## 7.6 まとめ
-
-この章では以下を学びました。
-
-| 概念 | F# の実現方法 | 他言語の対応 |
-|------|---------------|-------------|
-| 値オブジェクト | レコード型 | Rust: struct + derive, Java: record |
-| 構造的等価性 | レコード型のデフォルト | Rust: PartialEq, Java: equals |
-| カプセル化 | module + private | Rust: mod + pub, Java: class + private |
-| ファクトリ関数 | let createValue | Rust: fn new(), Java: static factory |
-
-次章では、**判別共用体** と **パターンマッチ** を導入して、FizzBuzz のタイプを型安全に表現します。

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

@@ -1,184 +0,0 @@
----
-type: Article
-title: "第 8 章: 判別共用体とパターンマッチ"
-description: "前章ではレコード型とモジュールによるカプセル化を実現しました。"
-tags: [article, getting-start-tdd, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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 プログラム全体のアーキテクチャを整理します。