@k2works/claude-code-booster 6.1.0 → 6.3.0

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

@@ -1,175 +0,0 @@
----
-type: Article
-title: "第 10 章: 高階関数と関数合成"
-description: "C# は LINQ やラムダ式を通じて関数型プログラミングの機能を豊富にサポートしています。"
-tags: [article, getting-start-tdd, csharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 10 章: 高階関数と関数合成
-
-## 10.1 はじめに
-
-C# は LINQ やラムダ式を通じて関数型プログラミングの機能を豊富にサポートしています。この章では **デリゲート** と **LINQ** を中心に、高階関数と関数合成の考え方を学びます。
-
-## 10.2 デリゲートとラムダ式
-
-C# のデリゲートは関数を値として扱うための仕組みです。`Func<T, TResult>` と `Action<T>` が代表的なデリゲート型です。
-
-```csharp
-// Func: 戻り値を持つ関数
-Func<int, int, int> add = (a, b) => a + b;
-Assert.Equal(5, add(2, 3));
-
-// Action: 戻り値を持たない関数
-Action<string> print = message => Console.WriteLine(message);
-
-// Predicate: bool を返す関数（Func<T, bool> のエイリアス）
-Predicate<int> isEven = n => n % 2 == 0;
-Assert.True(isEven(4));
-```
-
-Rust のクロージャ `|x| x * 2` に相当するのが C# のラムダ式 `x => x * 2` です。Rust のように所有権の概念はありませんが、キャプチャした変数の参照を保持する点は共通です。
-
-### 環境のキャプチャ
-
-```csharp
-int factor = 3;
-Func<int, bool> isMultiple = n => n % factor == 0;
-Assert.True(isMultiple(9));
-Assert.False(isMultiple(7));
-```
-
-## 10.3 LINQ と高階関数
-
-### Select — 要素の変換
-
-`Select` は各要素に関数を適用して変換します。Rust の `.map()` に相当します。
-
-```csharp
-var values = list.Values
-    .Select(v => v.Value)
-    .ToList();
-```
-
-### Where — 要素の選別
-
-`Where` は条件に一致する要素だけを残します。Rust の `.filter()` に相当します。
-
-```csharp
-var fizzValues = list.Values
-    .Where(v => v.Value == "Fizz")
-    .ToList();
-```
-
-### FirstOrDefault — 最初の一致要素
-
-`FirstOrDefault` は条件に一致する最初の要素を返します。Rust の `.find()` に相当します。
-
-```csharp
-var firstBuzz = list.Values
-    .FirstOrDefault(v => v.Value == "Buzz");
-```
-
-### Any / All — 条件判定
-
-```csharp
-bool hasFizzBuzz = list.Values
-    .Any(v => v.Value == "FizzBuzz");
-
-bool allNonEmpty = list.Values
-    .All(v => !string.IsNullOrEmpty(v.Value));
-```
-
-## 10.4 FizzBuzzList への関数型メソッド追加
-
-```csharp
-public class FizzBuzzList
-{
-    // ...既存のコード
-
-    public FizzBuzzList Filter(Func<FizzBuzzValue, bool> predicate)
-    {
-        return new FizzBuzzList(_values.Where(predicate).ToList());
-    }
-
-    public FizzBuzzValue? FindFirst(Func<FizzBuzzValue, bool> predicate)
-    {
-        return _values.FirstOrDefault(predicate);
-    }
-
-    public List<string> ToStringValues()
-    {
-        return _values.Select(v => v.Value).ToList();
-    }
-
-    public Dictionary<string, int> CountByValue()
-    {
-        return _values
-            .GroupBy(v => v.Value)
-            .ToDictionary(g => g.Key, g => g.Count());
-    }
-}
-```
-
-### テストの作成
-
-```csharp
-[Fact]
-public void フィルタリングできる()
-{
-    var list = new FizzBuzzList(new List<FizzBuzzValue>
-    {
-        new FizzBuzzValue(1, "1"),
-        new FizzBuzzValue(3, "Fizz"),
-        new FizzBuzzValue(5, "Buzz"),
-        new FizzBuzzValue(15, "FizzBuzz")
-    });
-    var filtered = list.Filter(v => v.Value == "Fizz");
-    Assert.Equal(1, filtered.Count);
-    Assert.Equal("Fizz", filtered.Get(0).Value);
-}
-
-[Fact]
-public void 最初の一致する値を取得できる()
-{
-    var list = new FizzBuzzList(new List<FizzBuzzValue>
-    {
-        new FizzBuzzValue(1, "1"),
-        new FizzBuzzValue(3, "Fizz"),
-        new FizzBuzzValue(6, "Fizz")
-    });
-    var found = list.FindFirst(v => v.Value == "Fizz");
-    Assert.NotNull(found);
-    Assert.Equal(3, found.Number);
-}
-
-[Fact]
-public void 値ごとにカウントできる()
-{
-    var list = new FizzBuzzList(new List<FizzBuzzValue>
-    {
-        new FizzBuzzValue(1, "1"),
-        new FizzBuzzValue(3, "Fizz"),
-        new FizzBuzzValue(6, "Fizz"),
-        new FizzBuzzValue(5, "Buzz")
-    });
-    var counts = list.CountByValue();
-    Assert.Equal(1, counts["1"]);
-    Assert.Equal(2, counts["Fizz"]);
-    Assert.Equal(1, counts["Buzz"]);
-}
-```
-
-## 10.5 まとめ
-
-| 概念 | C# | Rust | Java |
-|------|------|------|------|
-| クロージャ | `x => x * 2` | `\|x\| x * 2` | `x -> x * 2` |
-| map | `.Select(f)` | `.iter().map(f).collect()` | `.stream().map(f)` |
-| filter | `.Where(f)` | `.iter().filter(f).collect()` | `.stream().filter(f)` |
-| find | `.FirstOrDefault(f)` | `.iter().find(f)` → `Option` | `.stream().findFirst()` |
-| デリゲート | `Func<T, TResult>` | `Fn(T) -> TResult` | `Function<T, R>` |
-
-次章では、LINQ チェーンによるパイプライン処理と不変データの考え方を学びます。

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

@@ -1,201 +0,0 @@
----
-type: Article
-title: "第 11 章: 不変データとパイプライン処理"
-description: "前章ではデリゲートと LINQ を使った高階関数を学びました。"
-tags: [article, getting-start-tdd, csharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 11 章: 不変データとパイプライン処理
-
-## 11.1 はじめに
-
-前章ではデリゲートと LINQ を使った高階関数を学びました。この章では **LINQ チェーン** によるパイプライン処理と **不変データ** の考え方を深めます。
-
-## 11.2 C# の不変性
-
-C# では `readonly` キーワードと読み取り専用プロパティで不変性を実現します。
-
-```csharp
-// 読み取り専用フィールド
-private readonly List<FizzBuzzValue> _values;
-
-// 読み取り専用プロパティ（get のみ）
-public int Number { get; }
-public string Value { get; }
-```
-
-`FizzBuzzValue` はコンストラクタで値を設定した後は変更できません。Rust がデフォルトで不変（`let`）であるのに対し、C# では明示的に `readonly` や get のみのプロパティで不変性を宣言します。
-
-### イミュータブルな Add 操作
-
-`FizzBuzzList` の `Add` メソッドは、元のリストを変更せず新しいリストを返します。
-
-```csharp
-public FizzBuzzList Add(FizzBuzzValue value)
-{
-    var newValues = new List<FizzBuzzValue>(_values) { value };
-    return new FizzBuzzList(newValues);
-}
-```
-
-```csharp
-[Fact]
-public void 値を追加できる()
-{
-    var list = new FizzBuzzList();
-    var newList = list.Add(new FizzBuzzValue(1, "1"));
-    Assert.Equal(1, newList.Count);
-    Assert.Equal(0, list.Count); // 元のリストは変更されない
-}
-```
-
-## 11.3 LINQ チェーン（パイプライン）
-
-C# の LINQ はメソッドチェーンで連結でき、パイプライン処理を実現します。
-
-```csharp
-// パイプライン: Where → Select → ToList
-var fizzNumbers = list.Values
-    .Where(v => v.Value == "Fizz")
-    .Select(v => v.Number)
-    .ToList();
-```
-
-### Aggregate（集約）
-
-Rust の `.fold()` に相当する `Aggregate` で値を集約します。
-
-```csharp
-// 全 FizzBuzz 値を改行区切りで連結
-var joined = list.Values
-    .Select(v => v.Value)
-    .Aggregate((acc, v) => $"{acc}\n{v}");
-```
-
-### Take（先頭 N 件）
-
-```csharp
-var firstFive = list.Values
-    .Take(5)
-    .Select(v => v.Value)
-    .ToList();
-```
-
-### GroupBy（グループ化）
-
-Rust では `HashMap` を手動で構築する必要がありますが、C# では `GroupBy` が標準で提供されています。
-
-```csharp
-public Dictionary<string, int> CountByValue()
-{
-    return _values
-        .GroupBy(v => v.Value)
-        .ToDictionary(g => g.Key, g => g.Count());
-}
-```
-
-## 11.4 ImmutableList の活用
-
-`System.Collections.Immutable` パッケージを使うと、よりイミュータブルなコレクションを利用できます。
-
-```bash
-$ dotnet add package System.Collections.Immutable
-```
-
-```csharp
-using System.Collections.Immutable;
-
-// ImmutableList の使用例
-var immutableList = ImmutableList<FizzBuzzValue>.Empty;
-var newList = immutableList.Add(new FizzBuzzValue(1, "1"));
-
-// 元のリストは空のまま
-Assert.Equal(0, immutableList.Count);
-Assert.Equal(1, newList.Count);
-```
-
-`ImmutableList` は `Add` で常に新しいリストを返し、元のリストは変更されません。内部的にはバランス木を使って効率的に実装されています。
-
-## 11.5 FizzBuzzList のパイプライン操作
-
-```csharp
-public class FizzBuzzList
-{
-    // ...既存のコード
-
-    public FizzBuzzList AddRange(IEnumerable<FizzBuzzValue> values)
-    {
-        var newValues = new List<FizzBuzzValue>(_values);
-        newValues.AddRange(values);
-        return new FizzBuzzList(newValues);
-    }
-
-    public override string ToString()
-    {
-        return string.Join(", ", _values.Select(v => v.ToString()));
-    }
-
-    public bool Equals(FizzBuzzList? other)
-    {
-        if (other is null) return false;
-        if (ReferenceEquals(this, other)) return true;
-        return _values.SequenceEqual(other._values);
-    }
-
-    public override bool Equals(object? obj) => Equals(obj as FizzBuzzList);
-
-    public override int GetHashCode()
-    {
-        var hash = new HashCode();
-        foreach (var value in _values)
-            hash.Add(value);
-        return hash.ToHashCode();
-    }
-}
-```
-
-### テストの作成
-
-```csharp
-[Fact]
-public void AddRangeで複数の値を追加できる()
-{
-    var list = new FizzBuzzList();
-    var newList = list.AddRange(new List<FizzBuzzValue>
-    {
-        new FizzBuzzValue(1, "1"),
-        new FizzBuzzValue(2, "2")
-    });
-    Assert.Equal(2, newList.Count);
-}
-
-[Fact]
-public void 同じ内容のリストは等しい()
-{
-    var list1 = new FizzBuzzList(new List<FizzBuzzValue>
-    {
-        new FizzBuzzValue(1, "1"),
-        new FizzBuzzValue(3, "Fizz")
-    });
-    var list2 = new FizzBuzzList(new List<FizzBuzzValue>
-    {
-        new FizzBuzzValue(1, "1"),
-        new FizzBuzzValue(3, "Fizz")
-    });
-    Assert.Equal(list1, list2);
-}
-```
-
-## 11.6 まとめ
-
-| 概念 | C# | Rust | Java |
-|------|------|------|------|
-| 不変フィールド | `readonly` / get のみプロパティ | `let`（デフォルト不変） | `final` |
-| パイプライン | `.Where().Select().ToList()` | `.iter().filter().map().collect()` | `.stream().filter().map().collect()` |
-| 集約 | `.Aggregate(f)` | `.fold(init, f)` | `.reduce(f)` |
-| イミュータブルコレクション | `ImmutableList<T>` | `Vec<T>`（所有権で制御） | `List.of()` |
-| グループ化 | `.GroupBy(f).ToDictionary()` | `HashMap` 手動構築 | `.collect(groupingBy())` |
-
-次章では、Nullable 参照型とパターンマッチングを使ったエラーハンドリングと型安全性を学びます。

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

@@ -1,220 +0,0 @@
----
-type: Article
-title: "第 12 章: エラーハンドリングと型安全性"
-description: "前章では LINQ チェーンによるパイプライン処理を学びました。"
-tags: [article, getting-start-tdd, csharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 12 章: エラーハンドリングと型安全性
-
-## 12.1 はじめに
-
-前章では LINQ チェーンによるパイプライン処理を学びました。この最終章では、C# の **Nullable 参照型** と **パターンマッチング** を使ったエラーハンドリングと型安全性を学びます。
-
-## 12.2 Nullable 参照型
-
-C# 8.0 以降では、Nullable 参照型を有効にすることで null 安全性をコンパイル時にチェックできます。
-
-```xml
-<PropertyGroup>
-  <Nullable>enable</Nullable>
-</PropertyGroup>
-```
-
-### null 許容型と非 null 型
-
-```csharp
-string name = "hello";    // 非 null 型（null を代入するとコンパイラ警告）
-string? nullable = null;  // null 許容型（null を許容）
-```
-
-### FizzBuzzList での活用
-
-`FindFirst` メソッドは一致する要素が見つからない場合に `null` を返します。
-
-```csharp
-public FizzBuzzValue? FindFirst(Func<FizzBuzzValue, bool> predicate)
-{
-    return _values.FirstOrDefault(predicate);
-}
-```
-
-戻り値の型 `FizzBuzzValue?` は「null の可能性がある」ことを明示します。Rust の `Option<T>` に相当する C# の表現方法です。
-
-### テストの作成
-
-```csharp
-[Fact]
-public void 最初の一致する値を取得できる()
-{
-    var list = new FizzBuzzList(new List<FizzBuzzValue>
-    {
-        new FizzBuzzValue(1, "1"),
-        new FizzBuzzValue(3, "Fizz"),
-        new FizzBuzzValue(6, "Fizz")
-    });
-    var found = list.FindFirst(v => v.Value == "Fizz");
-    Assert.NotNull(found);
-    Assert.Equal(3, found.Number);
-}
-
-[Fact]
-public void 一致する値がない場合はnullを返す()
-{
-    var list = new FizzBuzzList(new List<FizzBuzzValue>
-    {
-        new FizzBuzzValue(1, "1"),
-        new FizzBuzzValue(2, "2")
-    });
-    var found = list.FindFirst(v => v.Value == "Fizz");
-    Assert.Null(found);
-}
-```
-
-## 12.3 パターンマッチング
-
-C# のパターンマッチングは `switch` 式で豊富なパターンを記述できます。
-
-### switch 式
-
-`FizzBuzzTypeFactory` は `switch` 式を使って型安全なファクトリを実現しています。
-
-```csharp
-public static IFizzBuzzType Create(int type)
-{
-    return type switch
-    {
-        1 => new FizzBuzzType01(),
-        2 => new FizzBuzzType02(),
-        3 => new FizzBuzzType03(),
-        _ => throw new ArgumentException($"Invalid FizzBuzz type: {type}")
-    };
-}
-```
-
-C# の `switch` 式は Rust の `match` 式に近く、値を返す式として使えます。`_` はデフォルトケース（Rust のワイルドカードに相当）です。
-
-### 型パターン
-
-`is` キーワードと型パターンで、オブジェクトの型をチェックしながらキャストできます。
-
-```csharp
-public bool Equals(object? obj)
-{
-    if (obj is FizzBuzzValue other)
-    {
-        return Number == other.Number && Value == other.Value;
-    }
-    return false;
-}
-```
-
-`obj is FizzBuzzValue other` は「`obj` が `FizzBuzzValue` 型であれば `other` に代入する」というパターンマッチングです。Rust の `if let Some(value) = option` に近い表現です。
-
-### null チェックパターン
-
-```csharp
-public bool Equals(FizzBuzzValue? other)
-{
-    if (other is null) return false;        // null パターン
-    if (ReferenceEquals(this, other)) return true;
-    return Number == other.Number && Value == other.Value;
-}
-```
-
-### FizzBuzzTypeName enum と switch 式
-
-```csharp
-public enum FizzBuzzTypeName
-{
-    Standard = 1,
-    NumberOnly = 2,
-    FizzBuzzOnly = 3
-}
-
-public static IFizzBuzzType Create(FizzBuzzTypeName name)
-{
-    return Create((int)name);
-}
-```
-
-enum を使うことで、タイプ番号をハードコーディングせずに型安全に指定できます。
-
-### テストの作成
-
-```csharp
-public class FizzBuzzTypeFactoryTest
-{
-    [Fact]
-    public void タイプ1を生成できる()
-    {
-        var type = FizzBuzzTypeFactory.Create(1);
-        Assert.IsType<FizzBuzzType01>(type);
-    }
-
-    [Fact]
-    public void 不正なタイプは例外を投げる()
-    {
-        Assert.Throws<ArgumentException>(
-            () => FizzBuzzTypeFactory.Create(0));
-    }
-
-    [Fact]
-    public void Enumで生成できる()
-    {
-        var type = FizzBuzzTypeFactory.Create(FizzBuzzTypeName.Standard);
-        Assert.IsType<FizzBuzzType01>(type);
-    }
-}
-```
-
-## 12.4 例外ハンドリング
-
-C# では `try-catch` と例外型の階層で例外を処理します。Rust の `Result<T, E>` とは異なるアプローチです。
-
-```csharp
-try
-{
-    var type = FizzBuzzTypeFactory.Create(0);
-}
-catch (ArgumentException ex)
-{
-    Console.WriteLine($"エラー: {ex.Message}");
-}
-```
-
-### Rust との比較
-
-| 概念 | C# | Rust |
-|------|------|------|
-| エラーの表現 | 例外（`Exception`） | `Result<T, E>` |
-| エラーの伝播 | `throw` / `try-catch` | `?` 演算子 |
-| null の表現 | `T?`（Nullable 参照型） | `Option<T>` |
-| null チェック | `is null` パターン | `match` / `if let` |
-
-C# は例外ベースのエラーハンドリングですが、Nullable 参照型とパターンマッチングにより、null に起因するバグをコンパイル時に検出できるようになっています。
-
-## 12.5 他言語との比較
-
-| 概念 | C# | Rust | Java | TypeScript |
-|------|------|------|------|------|
-| エラーハンドリング | `try-catch` | `Result<T, E>` | `try-catch` | `try-catch` |
-| null 安全 | `T?` (Nullable) | `Option<T>` | `Optional<T>` | `T \| null` |
-| 列挙型 | `enum`（整数ベース） | `enum`（代数的データ型） | `enum`（クラスベース） | `enum`（数値/文字列） |
-| パターンマッチ | `switch` 式 + 型パターン | `match`（網羅性チェック） | `switch` + `instanceof` | — |
-| エラー伝播 | `throw` | `?` 演算子 | `throws` | `throw` |
-
-## 12.6 まとめ
-
-この章では以下を学びました。
-
-| 概念 | C# の実現方法 |
-|------|-------------|
-| null 安全 | Nullable 参照型 (`T?`) + `<Nullable>enable</Nullable>` |
-| パターンマッチ | `switch` 式 + 型パターン + null パターン |
-| 型安全なファクトリ | `enum` + `switch` 式 |
-| 例外ハンドリング | `ArgumentException` + `try-catch` |
-
-全 12 章を通じて、C# の TDD 基本サイクル、開発環境の自動化、オブジェクト指向的な設計、関数型プログラミングの活用を一通り学びました。C# の強力な型システム、interface / abstract class、LINQ、Nullable 参照型、パターンマッチングは、安全で堅牢なソフトウェアを構築するための強力な基盤です。

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

@@ -1,83 +0,0 @@
-# テスト駆動開発から始める C# 入門
-
-## 概要
-
-FizzBuzz 問題を題材に、テスト駆動開発（TDD）の基本サイクルから、開発環境の整備、オブジェクト指向設計、関数型プログラミングの活用まで、C# の特徴を活かしながら段階的に学びます。
-
-## 対象読者
-
-- C# の基本文法を理解しているプログラミング学習者
-- TDD を体験してみたい開発者
-- オブジェクト指向設計や LINQ による関数型プログラミングに興味がある方
-
-## 前提条件
-
-- .NET 8.0 SDK 以降がインストールされていること
-- dotnet CLI が利用可能であること（Nix 環境推奨: `nix develop .#dotnet`）
-
-## C# の特徴
-
-| 特徴 | 説明 |
-|------|------|
-| 静的型付け + 型推論 | 強力な型システムと `var` による型推論 |
-| オブジェクト指向 | class, interface, abstract class による本格的な OOP |
-| 関数型要素 | LINQ, ラムダ式, デリゲートによる関数型プログラミング |
-| Nullable 参照型 | null 安全性をコンパイル時に検査 |
-| パターンマッチング | switch 式、型パターン、プロパティパターン |
-| クロスプラットフォーム | .NET による Windows / macOS / Linux 対応 |
-
-## 開発ツール
-
-| ツール | 用途 |
-|--------|------|
-| [xUnit.net](https://xunit.net/) | テスティングフレームワーク |
-| [NuGet](https://www.nuget.org/) | パッケージマネージャ |
-| [dotnet format](https://learn.microsoft.com/dotnet/core/tools/dotnet-format) | コードフォーマッター |
-| [Microsoft.CodeAnalysis.Analyzers](https://github.com/dotnet/roslyn-analyzers) | 静的コード解析 |
-| [Cake](https://cakebuild.net/) | ビルドスクリプト |
-
-## 目次
-
-### 第 1 部: TDD の基本サイクル
-
-1. [第 1 章: TODO リストと最初のテスト](chapter01.md)
-2. [第 2 章: 仮実装と三角測量](chapter02.md)
-3. [第 3 章: 明白な実装とリファクタリング](chapter03.md)
-
-### 第 2 部: 開発環境と自動化
-
-4. [第 4 章: バージョン管理と Conventional Commits](chapter04.md)
-5. [第 5 章: パッケージ管理と静的解析](chapter05.md)
-6. [第 6 章: タスクランナーと CI/CD](chapter06.md)
-
-### 第 3 部: オブジェクト指向設計
-
-7. [第 7 章: カプセル化とポリモーフィズム](chapter07.md)
-8. [第 8 章: デザインパターンの適用](chapter08.md)
-9. [第 9 章: SOLID 原則とモジュール設計](chapter09.md)
-
-### 第 4 部: 関数型プログラミングへの展開
-
-10. [第 10 章: 高階関数と関数合成](chapter10.md)
-11. [第 11 章: 不変データとパイプライン処理](chapter11.md)
-12. [第 12 章: エラーハンドリングと型安全性](chapter12.md)
-
-## 実装コード
-
-本記事のすべてのコード例は `apps/dotnet/` に実装されています。
-
-```bash
-# 開発環境に入る
-nix develop .#dotnet
-
-# テスト実行
-cd apps/dotnet
-dotnet test
-```
-
-## 参考文献
-
-- Kent Beck 著『テスト駆動開発』
-- Martin Fowler 著『リファクタリング: 既存のコードを安全に改善する』
-- Robert C. Martin 著『Clean Code: アジャイルソフトウェア達人の技』
-- Microsoft『C# プログラミングガイド』