@k2works/claude-code-booster 6.1.0 → 6.3.0

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

@@ -1,304 +0,0 @@
----
-type: Article
-title: "第 11 章: 不変データとパイプライン処理"
-tags: [article, getting-start-tdd, go]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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

@@ -1,419 +0,0 @@
----
-type: Article
-title: "第 12 章: エラーハンドリングと型安全性"
-tags: [article, getting-start-tdd, go]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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 のパターンマッチングとは異なるアプローチですが、同じ目的（安全性と明確さ）を実現しています。ジェネリクスの導入により、型安全な汎用プログラミングが可能になりました。