Day 022 — ジェネリクス基礎（型パラメータ）

📚 背景知識（読んでから問題へ）

Day 021では、embeddingが「コード再利用の道具」であり「型階層を作る道具」ではないことを学びました。しかし embedding には限界があります。MapやFilterのような「型に関係なく同じロジックを繰り返したい」処理には向きません。[]int用のSumInt、[]float64用のSumFloat64……と型ごとに関数を複製するか、interface{}（any）を使って型安全性を諦めるかの二択しかなかったのが、Go 1.17以前の状況でした。

Go 1.18で導入されたジェネリクス（型パラメータ）は、この問題を「型安全性を保ったままコードを1つにまとめる」形で解決します。

📋 コピーfunc Map[T, U any](s []T, f func(T) U) []U {
	result := make([]U, len(s))
	for i, v := range s {
		result[i] = f(v)
	}
	return result
}

[T, U any]が型パラメータリストです。関数名・型名の直後に[]で型パラメータを宣言し、その後ろの通常の引数・戻り値で型パラメータを使います。anyはinterface{}のエイリアスで、「どんな型でもよい」という最も緩い制約です。呼び出し側はMap(nums, func(n int) int { return n * 2 })のように書けば、コンパイラが型引数T=int, U=intを型推論するため、明示的にMap[int, int](...)と書く必要は通常ありません。

制約（constraint）はインターフェースとして表現します。anyより厳しい制約が必要な場合、例えば「数値型のみ許可し、+演算子で合計を取りたい」場合は、独自の制約インターフェースを定義します。

📋 コピーtype Number interface {
	~int | ~int64 | ~float64
}

|は「型の集合（union）」を意味し、「intまたはint64またはfloat64のいずれか」を表します。~intの~（チルダ）は「基底型（underlying type）がintであるすべての型」を意味します。これがないと、type Celsius intのような独自の名前付き型は、基底型がintであってもNumber制約を満たせません（Goの型システムでは名前付き型と元の型は別物として扱われるため）。

ジェネリクスは関数だけでなく、型（構造体）にも使えます。Stack[T any]のように書くと、任意の型Tのスタックを1つの実装で表現できます。これは「型ごとにIntStack, StringStackを書く」「interface{}で受けて呼び出し側でキャストする（実行時パニックのリスクを持つ）」という2つの悪い選択肢を、コンパイル時の型チェック付きで置き換えます。

📝 問題

汎用的なスライス操作ユーティリティと、ジェネリックなスタック型を実装してください。

Part A: MapとFilter

1. func Map[T, U any](s []T, f func(T) U) []U を実装すること。sの各要素にfを適用した結果のスライスを返す。
2. func Filter[T any](s []T, pred func(T) bool) []T を実装すること。predがtrueを返す要素だけを残したスライスを返す。

Part B: 制約付きジェネリクス

3. Number制約インターフェースを定義すること。int, int64, float64のいずれかの基底型を持つ型を許可する（~を使うこと）。
4. func Sum[T Number](s []T) T を実装すること。スライスの合計を返す。

Part C: ジェネリックなスタック型

5. Stack[T any]構造体を定義すること（内部は[]Tのスライスで構わない）。
6. メソッドPush(v T)（末尾に追加）、Pop() (T, bool)（末尾を取り出す。空ならTのゼロ値とfalse）、Len() int（要素数）を実装すること。

Part D: 制約の型安全性を実際に確認する

7. type Celsius float64という独自の名前付き型を定義し、Sum([]Celsius{...})がコンパイルできることを確認すること（~float64により許可される）。
8. 逆にSum([]string{"a", "b"})のような呼び出しはコンパイルエラーになることを、コメントで示すこと（実際にそのコード行はコメントアウトした状態で「これはコンパイルできない」という注記を残すこと。誤ってコンパイルエラーのコードをそのまま含めない）。

すべてgo runまたはgo testでそのまま動作するコードとして提示すること。

🔍 ヒント（段階的開示）

📋 コピーpackage main

import "fmt"

func Map[T, U any](s []T, f func(T) U) []U {
	// TODO
}

func Filter[T any](s []T, pred func(T) bool) []T {
	// TODO
}

type Number interface {
	// TODO: ~int | ~int64 | ~float64
}

func Sum[T Number](s []T) T {
	// TODO
}

type Stack[T any] struct {
	items []T
}

func (s *Stack[T]) Push(v T) {
	// TODO
}

func (s *Stack[T]) Pop() (T, bool) {
	// TODO
}

func (s *Stack[T]) Len() int {
	// TODO
}

type Celsius float64

func main() {
	nums := []int{1, 2, 3, 4, 5}
	fmt.Println(Map(nums, func(n int) int { return n * 2 }))
	fmt.Println(Filter(nums, func(n int) bool { return n%2 == 0 }))
	fmt.Println(Sum(nums))

	temps := []Celsius{10.5, 20.0, -3.5}
	fmt.Println(Sum(temps))

	var st Stack[string]
	st.Push("a")
	st.Push("b")
	v, ok := st.Pop()
	fmt.Println(v, ok, st.Len())
}

✅ 模範解答

ファイル: main.go

📋 コピーpackage main

import "fmt"

// ── Part A: Map と Filter ──

// Map は s の各要素に f を適用した結果のスライスを返す。
// T と U は異なる型でもよい（例: []int -> []string）。
func Map[T, U any](s []T, f func(T) U) []U {
	result := make([]U, len(s))
	for i, v := range s {
		result[i] = f(v)
	}
	return result
}

// Filter は pred が true を返す要素だけを残したスライスを返す。
func Filter[T any](s []T, pred func(T) bool) []T {
	result := make([]T, 0, len(s))
	for _, v := range s {
		if pred(v) {
			result = append(result, v)
		}
	}
	return result
}

// ── Part B: 制約付きジェネリクス ──

// Number は int/int64/float64、またはそれらを基底型に持つ独自の名前付き型を許可する。
// ~ (チルダ) がないと Celsius のような独自型は満たせない。
type Number interface {
	~int | ~int64 | ~float64
}

// Sum はスライスの合計を返す。T は Number 制約を満たす型に限定される。
func Sum[T Number](s []T) T {
	var total T // T のゼロ値（int なら 0, float64 なら 0.0）から開始
	for _, v := range s {
		total += v
	}
	return total
}

// ── Part C: ジェネリックなスタック型 ──

// Stack は任意の型 T の要素を保持するLIFOスタック。
type Stack[T any] struct {
	items []T
}

func (s *Stack[T]) Push(v T) {
	s.items = append(s.items, v)
}

// Pop は末尾の要素を取り出す。空なら T のゼロ値と false を返す。
func (s *Stack[T]) Pop() (T, bool) {
	var zero T
	if len(s.items) == 0 {
		return zero, false
	}
	last := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return last, true
}

func (s *Stack[T]) Len() int {
	return len(s.items)
}

// ── Part D: 制約の型安全性 ──

// Celsius は基底型が float64 の名前付き型。
// ~float64 のおかげで Number 制約を満たし、Sum([]Celsius{...}) がコンパイルできる。
type Celsius float64

// 【コンパイルできない例】以下はコメントアウトしたまま残す。
// string は Number 制約（~int | ~int64 | ~float64）を満たさないため、
// コメントを外すと「string does not implement Number」という
// コンパイルエラーになる。
//
// func brokenExample() {
// 	Sum([]string{"a", "b"}) // コンパイルエラー
// }

func main() {
	nums := []int{1, 2, 3, 4, 5}

	doubled := Map(nums, func(n int) int { return n * 2 })
	fmt.Println("doubled:", doubled)

	// T=int, U=string の異なる型パラメータの例
	labels := Map(nums, func(n int) string { return fmt.Sprintf("n%d", n) })
	fmt.Println("labels:", labels)

	evens := Filter(nums, func(n int) bool { return n%2 == 0 })
	fmt.Println("evens:", evens)

	fmt.Println("sum(nums):", Sum(nums))

	temps := []Celsius{10.5, 20.0, -3.5}
	fmt.Println("sum(temps):", Sum(temps)) // Celsius の基底型は float64 なので Number を満たす

	var st Stack[string]
	st.Push("a")
	st.Push("b")
	st.Push("c")
	fmt.Println("stack len:", st.Len())
	for {
		v, ok := st.Pop()
		if !ok {
			break
		}
		fmt.Println("popped:", v)
	}
}

ファイル: main_test.go

📋 コピーpackage main

import (
	"reflect"
	"testing"
)

func TestMap(t *testing.T) {
	got := Map([]int{1, 2, 3}, func(n int) int { return n * n })
	want := []int{1, 4, 9}
	if !reflect.DeepEqual(got, want) {
		t.Errorf("Map() = %v, want %v", got, want)
	}
}

func TestMapDifferentTypes(t *testing.T) {
	got := Map([]int{1, 2}, func(n int) string {
		if n == 1 {
			return "one"
		}
		return "two"
	})
	want := []string{"one", "two"}
	if !reflect.DeepEqual(got, want) {
		t.Errorf("Map() = %v, want %v", got, want)
	}
}

func TestFilter(t *testing.T) {
	got := Filter([]int{1, 2, 3, 4, 5, 6}, func(n int) bool { return n%2 == 0 })
	want := []int{2, 4, 6}
	if !reflect.DeepEqual(got, want) {
		t.Errorf("Filter() = %v, want %v", got, want)
	}
}

func TestSumInt(t *testing.T) {
	if got := Sum([]int{1, 2, 3}); got != 6 {
		t.Errorf("Sum() = %d, want 6", got)
	}
}

func TestSumFloat64(t *testing.T) {
	if got := Sum([]float64{1.5, 2.5}); got != 4.0 {
		t.Errorf("Sum() = %v, want 4.0", got)
	}
}

func TestSumNamedType(t *testing.T) {
	// Celsius の基底型は float64。~float64 制約により Sum に渡せる。
	if got := Sum([]Celsius{10, 20, -5}); got != 25 {
		t.Errorf("Sum() = %v, want 25", got)
	}
}

func TestStackPushPop(t *testing.T) {
	var s Stack[int]
	s.Push(1)
	s.Push(2)
	s.Push(3)
	if s.Len() != 3 {
		t.Fatalf("Len() = %d, want 3", s.Len())
	}
	v, ok := s.Pop()
	if !ok || v != 3 {
		t.Errorf("Pop() = (%d, %v), want (3, true)", v, ok)
	}
	if s.Len() != 2 {
		t.Errorf("Len() after Pop = %d, want 2", s.Len())
	}
}

func TestStackPopEmpty(t *testing.T) {
	var s Stack[string]
	v, ok := s.Pop()
	if ok || v != "" {
		t.Errorf("Pop() on empty stack = (%q, %v), want (\"\", false)", v, ok)
	}
}

$ go run .
doubled: [2 4 6 8 10]
labels: [n1 n2 n3 n4 n5]
evens: [2 4]
sum(nums): 15
sum(temps): 27
stack len: 3
popped: c
popped: b
popped: a

$ go test ./...
ok  	example.com/day022	0.003s

※ main.go・main_test.goを1つのモジュール（go.modでmodule example.com/day022と宣言、go 1.21以上を指定）として同一パッケージmainに配置しています。ジェネリクスにはGo 1.18以降が必要です。

🪜 Step-by-Step 解説

📋 コピーfunc Map[T, U any](s []T, f func(T) U) []U {
	result := make([]U, len(s))
	for i, v := range s {
		result[i] = f(v)
	}
	return result
}

📋 コピーfunc Filter[T any](s []T, pred func(T) bool) []T {
	result := make([]T, 0, len(s))
	for _, v := range s {
		if pred(v) {
			result = append(result, v)
		}
	}
	return result
}

📋 コピーtype Number interface {
	~int | ~int64 | ~float64
}

📋 コピーfunc Sum[T Number](s []T) T {
	var total T
	for _, v := range s {
		total += v
	}
	return total
}

📋 コピーtype Stack[T any] struct {
	items []T
}

func (s *Stack[T]) Push(v T) {
	s.items = append(s.items, v)
}

📋 コピーtype Celsius float64
// Sum([]Celsius{...}) は ~float64 のおかげでコンパイルできる

💡 設計思想・なぜこう書くのか

🌐 他言語との比較

Javaの型消去に慣れたエンジニアは「Goのジェネリクスも実行時には型情報が消えるのでは」と誤解しがちだが、Goは型ごとにコードを特殊化するため、リフレクションを使わずにreflect.TypeOf相当の情報が実行時にも保持される点が異なる。

🏆 実務での使いどころ

• 汎用スライス操作ライブラリ: Map/Filter/Reduceのような関数は、Go 1.21で標準ライブラリに追加されたslicesパッケージ（slices.Sort, slices.Contains等）やmapsパッケージのベースになっている考え方そのもの
• リポジトリパターンの共通化: Repository[T any]のようなジェネリックな型で、Repository[User]・Repository[Order]のようにドメインモデルごとのCRUD実装の重複を1つのコードにまとめられる（embeddingでは型ごとに書き分けが必要だった問題の直接的な解決策）
• 型安全なキャッシュ・コンテナ: Cache[K comparable, V any]のように、キーの型にcomparable制約（マップのキーに使える型のみ許可）を課したジェネリックなキャッシュ実装が典型的
• 数値計算・集計ロジックの共通化: Sum, Average, Min, Maxのような集計関数を、int/float64/独自の数値型（金額型・度数型など）に対して1つの実装で提供できる（Number制約のパターン）

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: Reduce[T, U any](s []T, initial U, f func(U, T) U) Uを実装し、Sum・Filterの組み合わせで書けていた処理をReduce一本でどう表現できるか試してみましょう。またcomparable制約を使ってContains[T comparable](s []T, target T) boolも書いてみると、制約の使い分けの感覚が掴めます
• 次回予告: Day 023 — testing パッケージ①（テーブル駆動テスト）（実装）。今日書いたMap/Filter/Sum/Stackのテストコードは素朴な個別関数として書きましたが、次回はGoの定石である「テーブル駆動テスト」のイディオムに書き直し、ケース追加のコストを最小化する設計を学びます

🎯 自己評価

自分の回答

気づき・メモ