@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/getting-start-tdd/go/11-immutable-data-and-pipeline.md

@@ -0,0 +1,296 @@
+# 第 11 章: 不変データとパイプライン処理
+
+## 11.1 不変データ設計の確認
+
+Go には `final` や `freeze` のようなキーワードがありませんが、**非公開フィールド + コンストラクタ + 防御的コピー**で不変性を実現できます。
+
+### FizzBuzzValue の不変設計
+
+第 8 章で作成した `FizzBuzzValue` は既に不変です:
+
+```go
+type FizzBuzzValue struct {
+    number int    // 非公開: 外部から変更不可
+    value  string // 非公開: 外部から変更不可
+}
+```
+
+- setter メソッドがない
+- フィールドが非公開（小文字）
+- 値レシーバを使用（ポインタでないため元の構造体は変更されない）
+
+### テスト: 不変性を確認する
+
+```go
+func TestFizzBuzzValue_不変性を確認する(t *testing.T) {
+    v1 := NewFizzBuzzValue(3, "Fizz")
+    // v1.number = 5  // コンパイルエラー: 非公開フィールドにアクセスできない
+    // v1 の値は変更できない
+    v2 := v1 // コピーが作成される（値型）
+    if !v1.Equal(v2) {
+        t.Fatal("v1 and v2 should be equal")
+    }
+}
+```
+
+### FizzBuzzList の不変設計
+
+```go
+type FizzBuzzList struct {
+    value []FizzBuzzValue // 非公開
+}
+```
+
+- `NewFizzBuzzList` でスライスをコピーして保持
+- `Value()` で防御的コピーを返す
+- `Filter` や `Map` は**新しいスライス/リスト**を返す（元のリストは変更しない）
+
+### テスト: Filter が元のリストを変更しないことを確認する
+
+```go
+func TestFizzBuzzList_Filterは元のリストを変更しない(t *testing.T) {
+    fbt := FizzBuzzType01{}
+    cmd := NewFizzBuzzListCommand(fbt, 15)
+    original := cmd.Execute().(*FizzBuzzList)
+    originalCount := original.Count()
+
+    isFizz := MakeValuePredicate("Fizz")
+    _ = original.Filter(isFizz)
+
+    if original.Count() != originalCount {
+        t.Fatal("original list should not be modified")
+    }
+}
+```
+
+## 11.2 パイプラインメソッド
+
+FizzBuzzList にパイプライン処理のためのメソッドを追加します。
+
+### テスト: GroupByValue — 値でグルーピングする
+
+```go
+func TestFizzBuzzList_GroupByValue_値でグルーピングする(t *testing.T) {
+    fbt := FizzBuzzType01{}
+    cmd := NewFizzBuzzListCommand(fbt, 15)
+    list := cmd.Execute().(*FizzBuzzList)
+
+    grouped := list.GroupByValue()
+
+    if _, ok := grouped["Fizz"]; !ok {
+        t.Fatal("grouped should contain 'Fizz' key")
+    }
+    if _, ok := grouped["Buzz"]; !ok {
+        t.Fatal("grouped should contain 'Buzz' key")
+    }
+    if _, ok := grouped["FizzBuzz"]; !ok {
+        t.Fatal("grouped should contain 'FizzBuzz' key")
+    }
+}
+```
+
+<details>
+<summary>実装コード: GroupByValue</summary>
+
+```go
+// GroupByValue は値でグルーピングした map を返します。
+func (l *FizzBuzzList) GroupByValue() map[string][]FizzBuzzValue {
+    result := make(map[string][]FizzBuzzValue)
+    for _, v := range l.value {
+        result[v.Value()] = append(result[v.Value()], v)
+    }
+    return result
+}
+```
+
+</details>
+
+### テスト: CountByValue — 値ごとの出現回数を数える
+
+```go
+func TestFizzBuzzList_CountByValue_値ごとの出現回数を数える(t *testing.T) {
+    fbt := FizzBuzzType01{}
+    cmd := NewFizzBuzzListCommand(fbt, 15)
+    list := cmd.Execute().(*FizzBuzzList)
+
+    counts := list.CountByValue()
+
+    if counts["FizzBuzz"] != 1 {
+        t.Fatalf("FizzBuzz count = %d, want 1", counts["FizzBuzz"])
+    }
+}
+```
+
+<details>
+<summary>実装コード: CountByValue</summary>
+
+```go
+// CountByValue は値ごとの出現回数を返します。
+func (l *FizzBuzzList) CountByValue() map[string]int {
+    result := make(map[string]int)
+    for _, v := range l.value {
+        result[v.Value()]++
+    }
+    return result
+}
+```
+
+</details>
+
+### テスト: Take — 先頭 N 件を取得する
+
+```go
+func TestFizzBuzzList_Take_先頭N件を取得する(t *testing.T) {
+    fbt := FizzBuzzType01{}
+    cmd := NewFizzBuzzListCommand(fbt, 15)
+    list := cmd.Execute().(*FizzBuzzList)
+
+    taken := list.Take(5)
+
+    if taken.Count() != 5 {
+        t.Fatalf("Take(5).Count() = %d, want 5", taken.Count())
+    }
+}
+```
+
+<details>
+<summary>実装コード: Take</summary>
+
+```go
+// Take は先頭から n 件の要素を含む新しいリストを返します。
+func (l *FizzBuzzList) Take(n int) *FizzBuzzList {
+    if n > len(l.value) {
+        n = len(l.value)
+    }
+    result := make([]FizzBuzzValue, n)
+    copy(result, l.value[:n])
+    return &FizzBuzzList{value: result}
+}
+```
+
+</details>
+
+### テスト: Join — 要素を文字列で結合する
+
+```go
+func TestFizzBuzzList_Join_要素を文字列で結合する(t *testing.T) {
+    values := []FizzBuzzValue{
+        NewFizzBuzzValue(1, "1"),
+        NewFizzBuzzValue(2, "2"),
+        NewFizzBuzzValue(3, "Fizz"),
+    }
+    list := NewFizzBuzzList(values)
+
+    got := list.Join(", ")
+
+    if got != "1, 2, Fizz" {
+        t.Fatalf("Join(', ') = %q, want %q", got, "1, 2, Fizz")
+    }
+}
+```
+
+<details>
+<summary>実装コード: Join</summary>
+
+```go
+// Join は各要素の文字列表現を区切り文字で結合した文字列を返します。
+func (l *FizzBuzzList) Join(sep string) string {
+    strs := make([]string, len(l.value))
+    for i, v := range l.value {
+        strs[i] = v.String()
+    }
+    return strings.Join(strs, sep)
+}
+```
+
+</details>
+
+## 11.3 メソッドチェーンによるパイプライン
+
+Filter と Take は `*FizzBuzzList` を返すため、**メソッドチェーン**でパイプラインを構築できます。
+
+### テスト: メソッドチェーンで Fizz を 3 件取得して結合する
+
+```go
+func TestFizzBuzzList_メソッドチェーンでパイプラインを構築する(t *testing.T) {
+    fbt := FizzBuzzType01{}
+    cmd := NewFizzBuzzListCommand(fbt, 100)
+    list := cmd.Execute().(*FizzBuzzList)
+
+    result := list.
+        Filter(MakeValuePredicate("Fizz")).
+        Take(3).
+        Join(", ")
+
+    if result != "Fizz, Fizz, Fizz" {
+        t.Fatalf("pipeline result = %q, want %q", result, "Fizz, Fizz, Fizz")
+    }
+}
+```
+
+### Reduce パターン
+
+Go には組み込みの `reduce` がありませんが、関数として実装できます。
+
+### テスト: Reduce で合計を計算する
+
+```go
+func TestFizzBuzzList_Reduce_数値の合計を計算する(t *testing.T) {
+    values := []FizzBuzzValue{
+        NewFizzBuzzValue(1, "1"),
+        NewFizzBuzzValue(2, "2"),
+        NewFizzBuzzValue(3, "Fizz"),
+    }
+    list := NewFizzBuzzList(values)
+
+    sum := list.Reduce(0, func(acc int, v FizzBuzzValue) int {
+        return acc + v.Number()
+    })
+
+    if sum != 6 {
+        t.Fatalf("Reduce sum = %d, want 6", sum)
+    }
+}
+```
+
+<details>
+<summary>実装コード: Reduce</summary>
+
+```go
+// Reducer は累積値と要素を受け取り新しい累積値を返す関数型です。
+type Reducer func(acc int, v FizzBuzzValue) int
+
+// Reduce は初期値から始めて各要素に関数を適用し、単一の値に畳み込みます。
+func (l *FizzBuzzList) Reduce(initial int, fn Reducer) int {
+    acc := initial
+    for _, v := range l.value {
+        acc = fn(acc, v)
+    }
+    return acc
+}
+```
+
+</details>
+
+## 11.4 各言語のパイプライン比較
+
+| 機能 | Go | Java | Ruby | TypeScript |
+|------|-----|------|------|------------|
+| パイプライン構文 | メソッドチェーン | Stream API | `then` / メソッドチェーン | メソッドチェーン |
+| グルーピング | 手動 `map` 構築 | `Collectors.groupingBy` | `group_by` | `reduce` |
+| 結合 | `strings.Join` | `Collectors.joining` | `join` | `Array.join` |
+| 畳み込み | 手動 `Reduce` | `Stream.reduce` | `reduce` / `inject` | `Array.reduce` |
+| 遅延評価 | なし（即時評価） | `Stream`（遅延） | `Lazy` | なし |
+
+Go はメソッドチェーンでパイプラインを構築しますが、Java の Stream API のような遅延評価はありません。すべての操作は即時評価されます。
+
+## 11.5 まとめ
+
+本章では以下を学びました:
+
+- **不変データ設計**: 非公開フィールド + 防御的コピーで不変性を実現
+- **パイプラインメソッド**: GroupByValue、CountByValue、Take、Join
+- **メソッドチェーン**: Filter → Take → Join のパイプライン構築
+- **Reduce パターン**: 畳み込みの手動実装
+
+Go のパイプラインは Java の Stream API ほど洗練されていませんが、メソッドチェーンを使って同等の処理を記述できます。不変設計は言語機能に頼らず、設計パターンで実現します。

package/lib/assets/docs/article/getting-start-tdd/go/12-error-handling-and-type-safety.md

@@ -0,0 +1,411 @@
+# 第 12 章: エラーハンドリングと型安全性
+
+## 12.1 error インターフェースと安全なファクトリ
+
+Go の標準的なエラーハンドリングは `error` インターフェースと多値返却です。第 7-9 章では `panic` を使用していましたが、Go の慣習に従い `error` を返すファクトリメソッドに改善します。
+
+### テスト: 安全なファクトリメソッド
+
+```go
+func TestTryNewFizzBuzzType_正常なタイプを生成できる(t *testing.T) {
+    fbt, err := TryNewFizzBuzzType(1)
+    if err != nil {
+        t.Fatalf("unexpected error: %v", err)
+    }
+    got := fbt.Generate(3)
+    if got.Value() != "Fizz" {
+        t.Fatalf("got.Value() = %q, want %q", got.Value(), "Fizz")
+    }
+}
+
+func TestTryNewFizzBuzzType_不正なタイプでエラーを返す(t *testing.T) {
+    _, err := TryNewFizzBuzzType(99)
+    if err == nil {
+        t.Fatal("expected error for invalid type")
+    }
+}
+```
+
+<details>
+<summary>実装コード: TryNewFizzBuzzType</summary>
+
+```go
+// TryNewFizzBuzzType は安全なファクトリです。不正なタイプでは error を返します。
+func TryNewFizzBuzzType(fizzBuzzType int) (FizzBuzzType, error) {
+    switch fizzBuzzType {
+    case 1:
+        return FizzBuzzType01{}, nil
+    case 2:
+        return FizzBuzzType02{}, nil
+    case 3:
+        return FizzBuzzType03{}, nil
+    default:
+        return nil, fmt.Errorf("該当するタイプは存在しません: %d", fizzBuzzType)
+    }
+}
+```
+
+</details>
+
+### テスト: 安全な FizzBuzzValue 生成
+
+```go
+func TestTryNewFizzBuzzValue_正の値で生成できる(t *testing.T) {
+    v, err := TryNewFizzBuzzValue(1, "1")
+    if err != nil {
+        t.Fatalf("unexpected error: %v", err)
+    }
+    if v.Number() != 1 {
+        t.Fatalf("Number() = %d, want 1", v.Number())
+    }
+}
+
+func TestTryNewFizzBuzzValue_負の値でエラーを返す(t *testing.T) {
+    _, err := TryNewFizzBuzzValue(-1, "-1")
+    if err == nil {
+        t.Fatal("expected error for negative number")
+    }
+}
+```
+
+<details>
+<summary>実装コード: TryNewFizzBuzzValue</summary>
+
+```go
+// TryNewFizzBuzzValue は安全なファクトリです。負の値では error を返します。
+func TryNewFizzBuzzValue(number int, value string) (FizzBuzzValue, error) {
+    if number < 0 {
+        return FizzBuzzValue{}, fmt.Errorf("値は正の値のみ許可します: %d", number)
+    }
+    return FizzBuzzValue{number: number, value: value}, nil
+}
+```
+
+</details>
+
+## 12.2 型スイッチによるパターンマッチング
+
+Go の型スイッチ（type switch）はインターフェース値の具体的な型で分岐するパターンマッチングです。
+
+### テスト: 型スイッチで FizzBuzzType の種類を判定する
+
+```go
+func TestDescribeFizzBuzzType_タイプ名を返す(t *testing.T) {
+    tests := []struct {
+        input int
+        want  string
+    }{
+        {1, "Standard"},
+        {2, "NumberOnly"},
+        {3, "FizzBuzzOnly"},
+    }
+    for _, tt := range tests {
+        fbt := NewFizzBuzzType(tt.input)
+        got := DescribeFizzBuzzType(fbt)
+        if got != tt.want {
+            t.Errorf("DescribeFizzBuzzType(%d) = %q, want %q", tt.input, got, tt.want)
+        }
+    }
+}
+```
+
+<details>
+<summary>実装コード: DescribeFizzBuzzType</summary>
+
+```go
+// DescribeFizzBuzzType は型スイッチで FizzBuzzType の種類を文字列で返します。
+func DescribeFizzBuzzType(fbt FizzBuzzType) string {
+    switch fbt.(type) {
+    case FizzBuzzType01:
+        return "Standard"
+    case FizzBuzzType02:
+        return "NumberOnly"
+    case FizzBuzzType03:
+        return "FizzBuzzOnly"
+    default:
+        return "Unknown"
+    }
+}
+```
+
+</details>
+
+## 12.3 型安全な列挙型ファクトリ
+
+マジックナンバーを排除し、型安全なファクトリパターンを導入します。
+
+### テスト: FizzBuzzTypeName で型安全にタイプを指定する
+
+```go
+func TestFizzBuzzTypeName_型安全にタイプを生成する(t *testing.T) {
+    fbt := CreateFizzBuzzType(FizzBuzzTypeStandard)
+    got := fbt.Generate(3)
+    if got.Value() != "Fizz" {
+        t.Fatalf("got.Value() = %q, want %q", got.Value(), "Fizz")
+    }
+}
+
+func TestFizzBuzzTypeName_全てのタイプを生成できる(t *testing.T) {
+    types := []FizzBuzzTypeName{
+        FizzBuzzTypeStandard,
+        FizzBuzzTypeNumberOnly,
+        FizzBuzzTypeFizzBuzzOnly,
+    }
+    for _, tn := range types {
+        fbt := CreateFizzBuzzType(tn)
+        if fbt == nil {
+            t.Fatalf("CreateFizzBuzzType(%v) should not return nil", tn)
+        }
+    }
+}
+```
+
+<details>
+<summary>実装コード: FizzBuzzTypeName</summary>
+
+```go
+// FizzBuzzTypeName は FizzBuzz タイプの型安全な識別子です。
+type FizzBuzzTypeName int
+
+const (
+    FizzBuzzTypeStandard     FizzBuzzTypeName = iota + 1 // 1
+    FizzBuzzTypeNumberOnly                                // 2
+    FizzBuzzTypeFizzBuzzOnly                              // 3
+)
+
+// CreateFizzBuzzType は FizzBuzzTypeName から FizzBuzzType を生成します。
+func CreateFizzBuzzType(name FizzBuzzTypeName) FizzBuzzType {
+    return NewFizzBuzzType(int(name))
+}
+```
+
+</details>
+
+## 12.4 FizzBuzzList の検索メソッド
+
+### テスト: FindFirst — 条件に合致する最初の要素を返す
+
+```go
+func TestFizzBuzzList_FindFirst_最初のFizzBuzzを見つける(t *testing.T) {
+    fbt := FizzBuzzType01{}
+    cmd := NewFizzBuzzListCommand(fbt, 100)
+    list := cmd.Execute().(*FizzBuzzList)
+
+    isFizzBuzz := MakeValuePredicate("FizzBuzz")
+    v, found := list.FindFirst(isFizzBuzz)
+
+    if !found {
+        t.Fatal("should find FizzBuzz")
+    }
+    if v.Number() != 15 {
+        t.Fatalf("Number() = %d, want 15", v.Number())
+    }
+}
+
+func TestFizzBuzzList_FindFirst_見つからない場合(t *testing.T) {
+    values := []FizzBuzzValue{NewFizzBuzzValue(1, "1")}
+    list := NewFizzBuzzList(values)
+
+    isFizzBuzz := MakeValuePredicate("FizzBuzz")
+    _, found := list.FindFirst(isFizzBuzz)
+
+    if found {
+        t.Fatal("should not find FizzBuzz")
+    }
+}
+```
+
+<details>
+<summary>実装コード: FindFirst</summary>
+
+```go
+// FindFirst は条件に合致する最初の要素を返します。
+// 見つからない場合は found が false になります。
+func (l *FizzBuzzList) FindFirst(pred Predicate) (FizzBuzzValue, bool) {
+    for _, v := range l.value {
+        if pred(v) {
+            return v, true
+        }
+    }
+    return FizzBuzzValue{}, false
+}
+```
+
+</details>
+
+### テスト: AnyMatch / AllMatch — 存在チェック
+
+```go
+func TestFizzBuzzList_AnyMatch_Fizzが存在する(t *testing.T) {
+    fbt := FizzBuzzType01{}
+    cmd := NewFizzBuzzListCommand(fbt, 15)
+    list := cmd.Execute().(*FizzBuzzList)
+
+    if !list.AnyMatch(MakeValuePredicate("Fizz")) {
+        t.Fatal("should contain Fizz")
+    }
+}
+
+func TestFizzBuzzList_AllMatch_全て数値ではない(t *testing.T) {
+    fbt := FizzBuzzType01{}
+    cmd := NewFizzBuzzListCommand(fbt, 15)
+    list := cmd.Execute().(*FizzBuzzList)
+
+    isNumber := func(v FizzBuzzValue) bool {
+        return v.Value() != "Fizz" && v.Value() != "Buzz" && v.Value() != "FizzBuzz"
+    }
+    if list.AllMatch(isNumber) {
+        t.Fatal("not all values should be numbers")
+    }
+}
+```
+
+<details>
+<summary>実装コード: AnyMatch / AllMatch</summary>
+
+```go
+// AnyMatch は条件に合致する要素が 1 つでもあれば true を返します。
+func (l *FizzBuzzList) AnyMatch(pred Predicate) bool {
+    for _, v := range l.value {
+        if pred(v) {
+            return true
+        }
+    }
+    return false
+}
+
+// AllMatch は全要素が条件に合致すれば true を返します。
+func (l *FizzBuzzList) AllMatch(pred Predicate) bool {
+    for _, v := range l.value {
+        if !pred(v) {
+            return false
+        }
+    }
+    return true
+}
+```
+
+</details>
+
+## 12.5 ジェネリクス（Go 1.18+）
+
+Go 1.18 で導入された型パラメータにより、型安全な汎用関数を書けるようになりました。
+
+### テスト: ジェネリック Map 関数
+
+```go
+func TestGenericMap_FizzBuzzValueを文字列に変換する(t *testing.T) {
+    values := []FizzBuzzValue{
+        NewFizzBuzzValue(1, "1"),
+        NewFizzBuzzValue(3, "Fizz"),
+    }
+
+    result := MapSlice(values, func(v FizzBuzzValue) string {
+        return v.Value()
+    })
+
+    if result[0] != "1" || result[1] != "Fizz" {
+        t.Fatalf("MapSlice result = %v", result)
+    }
+}
+```
+
+<details>
+<summary>実装コード: MapSlice（ジェネリクス）</summary>
+
+```go
+// MapSlice は任意の型のスライスに関数を適用し、変換結果のスライスを返します。
+func MapSlice[T any, R any](slice []T, fn func(T) R) []R {
+    result := make([]R, len(slice))
+    for i, v := range slice {
+        result[i] = fn(v)
+    }
+    return result
+}
+```
+
+</details>
+
+### テスト: ジェネリック Filter 関数
+
+```go
+func TestGenericFilter_正の値だけを抽出する(t *testing.T) {
+    numbers := []int{-2, -1, 0, 1, 2, 3}
+    positives := FilterSlice(numbers, func(n int) bool { return n > 0 })
+
+    if len(positives) != 3 {
+        t.Fatalf("len(positives) = %d, want 3", len(positives))
+    }
+}
+```
+
+<details>
+<summary>実装コード: FilterSlice（ジェネリクス）</summary>
+
+```go
+// FilterSlice は条件に合致する要素だけを含む新しいスライスを返します。
+func FilterSlice[T any](slice []T, pred func(T) bool) []T {
+    var result []T
+    for _, v := range slice {
+        if pred(v) {
+            result = append(result, v)
+        }
+    }
+    return result
+}
+```
+
+</details>
+
+### テスト: ジェネリック Reduce 関数
+
+```go
+func TestGenericReduce_合計を計算する(t *testing.T) {
+    numbers := []int{1, 2, 3, 4, 5}
+    sum := ReduceSlice(numbers, 0, func(acc, n int) int { return acc + n })
+
+    if sum != 15 {
+        t.Fatalf("ReduceSlice sum = %d, want 15", sum)
+    }
+}
+```
+
+<details>
+<summary>実装コード: ReduceSlice（ジェネリクス）</summary>
+
+```go
+// ReduceSlice は初期値から始めて各要素に関数を適用し、単一の値に畳み込みます。
+func ReduceSlice[T any, R any](slice []T, initial R, fn func(R, T) R) R {
+    acc := initial
+    for _, v := range slice {
+        acc = fn(acc, v)
+    }
+    return acc
+}
+```
+
+</details>
+
+## 12.6 各言語のエラーハンドリング比較
+
+| 機能 | Go | Java | Ruby | TypeScript |
+|------|-----|------|------|------------|
+| エラー型 | `error` インターフェース | 例外（`Exception`） | 例外（`StandardError`） | 例外（`Error`） |
+| null 安全 | 多値返却 `(T, error)` | `Optional<T>` | `nil` / `try_create` | `T \| undefined` |
+| パターンマッチング | 型スイッチ | `instanceof` / `switch` | `case/in` | `typeof` / `switch` |
+| ジェネリクス | 型パラメータ `[T any]` | `<T>` | なし（動的型付け） | `<T>` |
+| 型安全な列挙 | `iota` + 型定義 | `enum` | 定数モジュール | `enum` / Union 型 |
+
+Go のエラーハンドリングは例外を使わず、明示的な `error` 返却により呼び出し側にエラー処理を強制します。これは冗長に見えますが、エラーの流れを追跡しやすい利点があります。
+
+## 12.7 まとめ
+
+本章では以下を学びました:
+
+- **error インターフェース**: `panic` から `error` 返却への改善（`TryNewFizzBuzzType`、`TryNewFizzBuzzValue`）
+- **型スイッチ**: インターフェース値の具体的な型で分岐するパターンマッチング
+- **型安全な列挙型**: `iota` を使ったマジックナンバーの排除（`FizzBuzzTypeName`）
+- **検索メソッド**: `FindFirst`、`AnyMatch`、`AllMatch`
+- **ジェネリクス**: `MapSlice[T, R]`、`FilterSlice[T]`、`ReduceSlice[T, R]` による汎用関数
+
+Go のエラーハンドリングと型システムは Java の `Optional` や Ruby のパターンマッチングとは異なるアプローチですが、同じ目的（安全性と明確さ）を実現しています。ジェネリクスの導入により、型安全な汎用プログラミングが可能になりました。