Go ジェネリクス完全ガイド 2026年版：型パラメータ、制約、面接対策

// 型パラメータTを持つ基本的なジェネリック関数
func PrintSlice[T any](items []T) {
    for _, item := range items {
        fmt.Println(item)
    }
}

// 使用例 - 型推論がTを自動的に決定
func main() {
    PrintSlice([]int{1, 2, 3})        // Tはint
    PrintSlice([]string{"a", "b"})     // Tはstring
}

// any: すべての型を受け入れる（interface{}のエイリアス）
func Process[T any](value T) T {
    return value
}

// comparable: == と != をサポートする型のみ
func Contains[T comparable](slice []T, target T) bool {
    for _, v := range slice {
        if v == target {  // この比較にはcomparableが必要
            return true
        }
    }
    return false
}

// これはコンパイルされる
Contains([]int{1, 2, 3}, 2)

// これは失敗：スライスはcomparableではない
// Contains([][]int{{1}, {2}}, []int{1})

// 型共用体を使用したカスタム制約
type Number interface {
    int | int8 | int16 | int32 | int64 |
    uint | uint8 | uint16 | uint32 | uint64 |
    float32 | float64
}

// 数値型に制約されたジェネリック関数
func Sum[T Number](values []T) T {
    var total T
    for _, v := range values {
        total += v  // すべてのNumber型が+をサポートするため動作
    }
    return total
}

func main() {
    fmt.Println(Sum([]int{1, 2, 3}))         // 6
    fmt.Println(Sum([]float64{1.5, 2.5}))    // 4.0
}

// ~intはintと基底型がintのすべての型にマッチ
type Signed interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}

// 基底型がintのカスタム型
type UserID int
type Temperature int64

func Abs[T Signed](value T) T {
    if value < 0 {
        return -value
    }
    return value
}

func main() {
    var id UserID = -42
    var temp Temperature = -10
    
    fmt.Println(Abs(id))    // 42 - ~intがUserIDにマッチするため動作
    fmt.Println(Abs(temp))  // 10 - ~int64がTemperatureにマッチするため動作
}

// ジェネリックStack型
type Stack[T any] struct {
    items []T
}

// Pushはスタックに要素を追加
func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

// Popは先頭要素を削除して返す
func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T  // 型Tのゼロ値
        return zero, false
    }
    index := len(s.items) - 1
    item := s.items[index]
    s.items = s.items[:index]
    return item, true
}

func main() {
    intStack := Stack[int]{}
    intStack.Push(10)
    intStack.Push(20)
    
    val, ok := intStack.Pop()  // val=20, ok=true
}

// これは有効なGoコードではない
type Container[T any] struct {
    value T
}

// エラー：メソッドは型パラメータを持てない
// func (c *Container[T]) Transform[U any](fn func(T) U) U {
//     return fn(c.value)
// }

// 有効な代替案：スタンドアロン関数を使用
func Transform[T, U any](c *Container[T], fn func(T) U) U {
    return fn(c.value)
}

func Map[T, R any](input []T, transform func(T) R) []R {
    result := make([]R, len(input))
    for i, v := range input {
        result[i] = transform(v)
    }
    return result
}

func main() {
    numbers := []int{1, 2, 3}
    
    // 型推論：T=int、R=stringは引数から推論される
    strings := Map(numbers, func(n int) string {
        return fmt.Sprintf("%d", n)
    })
    
    // 複雑なケースでは明示的な型が必要な場合がある
    // Map[int, string](numbers, converter)
}

import (
    "cmp"
    "slices"
)

func main() {
    numbers := []int{3, 1, 4, 1, 5, 9}
    
    // slices.Sortは内部でcmp.Ordered制約を使用
    slices.Sort(numbers)  // [1, 1, 3, 4, 5, 9]
    
    // ソート済みスライスでの二分探索
    index, found := slices.BinarySearch(numbers, 4)
    
    // cmp.Compareは-1、0、または1を返す
    result := cmp.Compare(3, 5)  // -1
    
    // cmp.Orは最初のゼロでない値を返す
    value := cmp.Or(0, 0, 42, 100)  // 42
}

import (
    "sync"
    "time"
)

type Cache[K comparable, V any] struct {
    mu    sync.RWMutex
    items map[K]cacheItem[V]
}

type cacheItem[V any] struct {
    value      V
    expiration time.Time
}

func NewCache[K comparable, V any]() *Cache[K, V] {
    return &Cache[K, V]{
        items: make(map[K]cacheItem[V]),
    }
}

func (c *Cache[K, V]) Set(key K, value V, ttl time.Duration) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.items[key] = cacheItem[V]{
        value:      value,
        expiration: time.Now().Add(ttl),
    }
}

func (c *Cache[K, V]) Get(key K) (V, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    
    item, exists := c.items[key]
    if !exists || time.Now().After(item.expiration) {
        var zero V
        return zero, false
    }
    return item.value, true
}

// スライスが空の場合にゼロ値を返す
func First[T any](slice []T) T {
    if len(slice) == 0 {
        var zero T  // ゼロ値：intは0、stringは""、ポインタはnil
        return zero
    }
    return slice[0]
}

// 代替案：曖昧さを避けるためにポインタを返す
func FirstOrNil[T any](slice []T) *T {
    if len(slice) == 0 {
        return nil
    }
    return &slice[0]
}

// 順序付けと文字列変換の両方を必要とする制約
type Stringable interface {
    String() string
}

type OrderedStringable interface {
    cmp.Ordered
    Stringable
}

// 代替案：インラインで複数の制約を持つ型パラメータを使用
func PrintSorted[T interface{ cmp.Ordered; fmt.Stringer }](items []T) {
    slices.Sort(items)
    for _, item := range items {
        fmt.Println(item.String())
    }
}