package main
 
import (
    "cmp"
    "fmt"
)
 
// T は cmp.Ordered を満たす任意の型
func MaxT cmp.Ordered T {
    if a > b {
        return a
    }
    return b
}
 
func MinT cmp.Ordered T {
    if a < b {
        return a
    }
    return b
}
 
func ClampT cmp.Ordered T {
    return Max(lo, Min(val, hi))
}
 
func main() {
    fmt.Println(Max(3, 7))           // 7
    fmt.Println(Max(3.14, 2.71))     // 3.14
    fmt.Println(Max("apple", "banana")) // banana
    fmt.Println(Clamp(150, 0, 100))  // 100
}

// Map はスライスの各要素に関数を適用する
func MapT, U any U) []U {
    result := make([]U, len(s))
    for i, v := range s {
        result[i] = f(v)
    }
    return result
}
 
// Filter はスライスから条件を満たす要素を抽出する
func FilterT any bool) []T {
    var result []T
    for _, v := range s {
        if pred(v) {
            result = append(result, v)
        }
    }
    return result
}
 
// Reduce はスライスを単一の値に集約する
func ReduceT, U any U) U {
    acc := init
    for _, v := range s {
        acc = f(acc, v)
    }
    return acc
}
 
// Find は条件を満たす最初の要素を返す
func FindT any bool) (T, bool) {
    for _, v := range s {
        if pred(v) {
            return v, true
        }
    }
    var zero T
    return zero, false
}
 
// GroupBy はキー関数に基づいてグルーピングする
func GroupByT any, K comparable K) map[K][]T {
    result := make(map[K][]T)
    for _, v := range s {
        key := keyFn(v)
        result[key] = append(result[key], v)
    }
    return result
}
 
// Chunk はスライスを指定サイズのチャンクに分割する
func ChunkT any [][]T {
    if size <= 0 {
        return nil
    }
    var chunks [][]T
    for i := 0; i < len(s); i += size {
        end := i + size
        if end > len(s) {
            end = len(s)
        }
        chunks = append(chunks, s[i:end])
    }
    return chunks
}
 
// Unique は重複を排除したスライスを返す
func UniqueT comparable []T {
    seen := make(map[T]struct{})
    var result []T
    for _, v := range s {
        if _, ok := seen[v]; !ok {
            seen[v] = struct{}{}
            result = append(result, v)
        }
    }
    return result
}
 
// 使用例
func main() {
    nums := []int{1, 2, 3, 4, 5}
    doubled := Map(nums, func(n int) int { return n * 2 })
    // [2, 4, 6, 8, 10]
 
    evens := Filter(nums, func(n int) bool { return n%2 == 0 })
    // [2, 4]
 
    sum := Reduce(nums, 0, func(acc, n int) int { return acc + n })
    // 15
 
    // 文字列操作
    words := []string{"hello", "world", "go", "generics"}
    lengths := Map(words, func(s string) int { return len(s) })
    // [5, 5, 2, 8]
 
    longWords := Filter(words, func(s string) bool { return len(s) > 3 })
    // ["hello", "world", "generics"]
 
    // グルーピング
    type User struct {
        Name string
        Role string
    }
    users := []User{
        {"Alice", "admin"}, {"Bob", "user"}, {"Charlie", "admin"}, {"Dave", "user"},
    }
    byRole := GroupBy(users, func(u User) string { return u.Role })
    // map["admin":[Alice, Charlie] "user":[Bob, Dave]]
 
    // 重複排除
    ids := []int{1, 2, 3, 2, 1, 4, 3, 5}
    unique := Unique(ids) // [1, 2, 3, 4, 5]
}

// FlatMap はスライスの各要素をスライスに変換してフラット化する
func FlatMapT, U any []U) []U {
    var result []U
    for _, v := range s {
        result = append(result, f(v)...)
    }
    return result
}
 
// Zip は2つのスライスを組にする
func ZipT, U any []Pair[T, U] {
    minLen := len(a)
    if len(b) < minLen {
        minLen = len(b)
    }
    result := make([]Pair[T, U], minLen)
    for i := 0; i < minLen; i++ {
        result[i] = Pair[T, U]{First: a[i], Second: b[i]}
    }
    return result
}
 
type Pair[T, U any] struct {
    First  T
    Second U
}
 
// Partition は条件に基づいてスライスを2つに分割する
func PartitionT any bool) (matched, unmatched []T) {
    for _, v := range s {
        if pred(v) {
            matched = append(matched, v)
        } else {
            unmatched = append(unmatched, v)
        }
    }
    return
}
 
// 使用例
func example() {
    // FlatMap: 文をトークンに分割
    sentences := []string{"hello world", "go generics"}
    tokens := FlatMap(sentences, func(s string) []string {
        return strings.Split(s, " ")
    })
    // ["hello", "world", "go", "generics"]
 
    // Zip: 名前とスコアを組にする
    names := []string{"Alice", "Bob", "Charlie"}
    scores := []int{90, 85, 95}
    pairs := Zip(names, scores)
    // [{Alice, 90}, {Bob, 85}, {Charlie, 95}]
 
    // Partition: 合格と不合格に分ける
    pass, fail := Partition(scores, func(s int) bool { return s >= 90 })
    // pass: [90, 95], fail: [85]
}

// メソッドベースの制約
type Stringer interface {
    String() string
}
 
// 型集合ベースの制約（union）
type Number interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
    ~float32 | ~float64
}
 
// 整数のみの制約
type Integer interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}
 
// 浮動小数点のみの制約
type Float interface {
    ~float32 | ~float64
}
 
// チルダ (~) は基底型を指定
// ~int は「基底型が int である全ての型」を含む
type MyInt int      // ~int に含まれる
type Score int      // ~int に含まれる
 
// 複合制約: メソッド + 型集合
type OrderedStringer interface {
    cmp.Ordered
    String() string
}
 
// 実用例: Sum 関数
func SumT Number T {
    var total T
    for _, n := range nums {
        total += n
    }
    return total
}
 
// 実用例: Average 関数（浮動小数点を返す）
func AverageT Number float64 {
    if len(nums) == 0 {
        return 0
    }
    var sum T
    for _, n := range nums {
        sum += n
    }
    return float64(sum) / float64(len(nums))
}
 
// 実用例: Abs 関数（符号付き数値）
type Signed interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 | ~float32 | ~float64
}
 
func AbsT Signed T {
    if v < 0 {
        return -v
    }
    return v
}
 
fmt.Println(Sum([]int{1, 2, 3}))        // 6
fmt.Println(Sum([]float64{1.1, 2.2}))   // 3.3
fmt.Println(Average([]int{10, 20, 30})) // 20.0
fmt.Println(Abs(-42))                    // 42

// Comparable + Stringer を両方満たす制約
type ComparableStringer interface {
    comparable
    String() string
}
 
// マップのキーとして使え、文字列表現を持つ型
func PrintMapK ComparableStringer, V any {
    for k, v := range m {
        fmt.Printf("%s: %v\n", k.String(), v)
    }
}
 
// 制約インターフェースの合成
type Numeric interface {
    Integer | Float
}
 
type Addable interface {
    Numeric
    comparable
}
 
// JSON シリアライズ可能な制約
type JSONSerializable interface {
    comparable
    MarshalJSON() ([]byte, error)
    UnmarshalJSON([]byte) error
}
 
// バリデーション可能な制約
type Validatable interface {
    Validate() error
}
 
// バリデーション付きの保存関数
func SaveAllT Validatable error {
    for i, item := range items {
        if err := item.Validate(); err != nil {
            return fmt.Errorf("item[%d]: %w", i, err)
        }
    }
    // 保存処理...
    return nil
}

// スタック
type Stack[T any] struct {
    items []T
}
 
func NewStack[T any]() *Stack[T] {
    return &Stack[T]{}
}
 
func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}
 
func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    last := len(s.items) - 1
    item := s.items[last]
    s.items = s.items[:last]
    return item, true
}
 
func (s *Stack[T]) Peek() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    return s.items[len(s.items)-1], true
}
 
func (s *Stack[T]) Len() int {
    return len(s.items)
}
 
func (s *Stack[T]) IsEmpty() bool {
    return len(s.items) == 0
}
 
// 使用例
intStack := NewStack[int]()
intStack.Push(1)
intStack.Push(2)
val, _ := intStack.Pop() // 2
 
strStack := NewStack[string]()
strStack.Push("hello")

// Queue はジェネリックなFIFOキュー
type Queue[T any] struct {
    items []T
}
 
func NewQueue[T any]() *Queue[T] {
    return &Queue[T]{}
}
 
func (q *Queue[T]) Enqueue(item T) {
    q.items = append(q.items, item)
}
 
func (q *Queue[T]) Dequeue() (T, bool) {
    if len(q.items) == 0 {
        var zero T
        return zero, false
    }
    item := q.items[0]
    q.items = q.items[1:]
    return item, true
}
 
func (q *Queue[T]) Peek() (T, bool) {
    if len(q.items) == 0 {
        var zero T
        return zero, false
    }
    return q.items[0], true
}
 
func (q *Queue[T]) Len() int {
    return len(q.items)
}
 
// PriorityQueue は優先度付きキュー
type PriorityQueue[T any] struct {
    items []T
    less  func(a, b T) bool
}
 
func NewPriorityQueueT any bool) *PriorityQueue[T] {
    return &PriorityQueue[T]{less: less}
}
 
func (pq *PriorityQueue[T]) Push(item T) {
    pq.items = append(pq.items, item)
    pq.up(len(pq.items) - 1)
}
 
func (pq *PriorityQueue[T]) Pop() (T, bool) {
    if len(pq.items) == 0 {
        var zero T
        return zero, false
    }
    n := len(pq.items) - 1
    pq.items[0], pq.items[n] = pq.items[n], pq.items[0]
    item := pq.items[n]
    pq.items = pq.items[:n]
    if n > 0 {
        pq.down(0)
    }
    return item, true
}
 
func (pq *PriorityQueue[T]) up(j int) {
    for {
        i := (j - 1) / 2
        if i == j || !pq.less(pq.items[j], pq.items[i]) {
            break
        }
        pq.items[i], pq.items[j] = pq.items[j], pq.items[i]
        j = i
    }
}
 
func (pq *PriorityQueue[T]) down(i int) {
    n := len(pq.items)
    for {
        left := 2*i + 1
        if left >= n {
            break
        }
        j := left
        if right := left + 1; right < n && pq.less(pq.items[right], pq.items[left]) {
            j = right
        }
        if !pq.less(pq.items[j], pq.items[i]) {
            break
        }
        pq.items[i], pq.items[j] = pq.items[j], pq.items[i]
        i = j
    }
}
 
func (pq *PriorityQueue[T]) Len() int {
    return len(pq.items)
}
 
// 使用例
pq := NewPriorityQueue(func(a, b int) bool { return a < b })
pq.Push(3)
pq.Push(1)
pq.Push(2)
val, _ := pq.Pop() // 1（最小値が先に出る）

// SyncMap はジェネリックな並行安全マップ
type SyncMap[K comparable, V any] struct {
    mu sync.RWMutex
    m  map[K]V
}
 
func NewSyncMap[K comparable, V any]() *SyncMap[K, V] {
    return &SyncMap[K, V]{
        m: make(map[K]V),
    }
}
 
func (sm *SyncMap[K, V]) Get(key K) (V, bool) {
    sm.mu.RLock()
    defer sm.mu.RUnlock()
    val, ok := sm.m[key]
    return val, ok
}
 
func (sm *SyncMap[K, V]) Set(key K, value V) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    sm.m[key] = value
}
 
func (sm *SyncMap[K, V]) Delete(key K) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    delete(sm.m, key)
}
 
func (sm *SyncMap[K, V]) Len() int {
    sm.mu.RLock()
    defer sm.mu.RUnlock()
    return len(sm.m)
}
 
func (sm *SyncMap[K, V]) Range(fn func(K, V) bool) {
    sm.mu.RLock()
    defer sm.mu.RUnlock()
    for k, v := range sm.m {
        if !fn(k, v) {
            break
        }
    }
}
 
// GetOrSet は値が存在しなければ設定して返す
func (sm *SyncMap[K, V]) GetOrSet(key K, defaultVal V) V {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    if val, ok := sm.m[key]; ok {
        return val
    }
    sm.m[key] = defaultVal
    return defaultVal
}
 
// 使用例
cache := NewSyncMap[string, int]()
cache.Set("count", 42)
val, ok := cache.Get("count") // 42, true

// Result はエラーまたは値を持つ型
type Result[T any] struct {
    value T
    err   error
}
 
func OkT any Result[T] {
    return Result[T]{value: value}
}
 
func ErrT any Result[T] {
    return Result[T]{err: err}
}
 
func (r Result[T]) IsOk() bool {
    return r.err == nil
}
 
func (r Result[T]) IsErr() bool {
    return r.err != nil
}
 
func (r Result[T]) Unwrap() (T, error) {
    return r.value, r.err
}
 
func (r Result[T]) UnwrapOr(defaultVal T) T {
    if r.err != nil {
        return defaultVal
    }
    return r.value
}
 
func (r Result[T]) UnwrapOrElse(fn func(error) T) T {
    if r.err != nil {
        return fn(r.err)
    }
    return r.value
}
 
// Map: 値がある場合のみ変換を適用
func MapResultT, U any U) Result[U] {
    if r.err != nil {
        return ErrU
    }
    return Ok(f(r.value))
}
 
// FlatMap: 値がある場合に別のResult生成関数を適用
func FlatMapResultT, U any Result[U]) Result[U] {
    if r.err != nil {
        return ErrU
    }
    return f(r.value)
}
 
// Collect: Result のスライスから成功値を収集（1つでもエラーなら失敗）
func CollectT any Result[[]T] {
    values := make([]T, 0, len(results))
    for _, r := range results {
        if r.IsErr() {
            return Err[[]T](r.err)
        }
        values = append(values, r.value)
    }
    return Ok(values)
}
 
// 使用例
result := Ok(42)
doubled := MapResult(result, func(n int) int { return n * 2 })
val, _ := doubled.Unwrap() // 84
 
// チェーン
func fetchUser(id string) Result[User] {
    user, err := db.FindUser(id)
    if err != nil {
        return ErrUser
    }
    return Ok(*user)
}
 
func getEmail(u User) Result[string] {
    if u.Email == "" {
        return Errstring)
    }
    return Ok(u.Email)
}
 
// Result チェーン
email := FlatMapResult(fetchUser("123"), getEmail)
fmt.Println(email.UnwrapOr("no-email@example.com"))

// Optional はnil安全な値コンテナ
type Optional[T any] struct {
    value *T
}
 
func SomeT any Optional[T] {
    return Optional[T]{value: &v}
}
 
func None[T any]() Optional[T] {
    return Optional[T]{}
}
 
func (o Optional[T]) IsPresent() bool {
    return o.value != nil
}
 
func (o Optional[T]) Get() (T, bool) {
    if o.value == nil {
        var zero T
        return zero, false
    }
    return *o.value, true
}
 
func (o Optional[T]) OrElse(defaultVal T) T {
    if o.value == nil {
        return defaultVal
    }
    return *o.value
}
 
func (o Optional[T]) IfPresent(fn func(T)) {
    if o.value != nil {
        fn(*o.value)
    }
}
 
func MapOptionalT, U any U) Optional[U] {
    if o.value == nil {
        return None[U]()
    }
    return Some(f(*o.value))
}
 
// 使用例
name := Some("Alice")
name.IfPresent(func(n string) {
    fmt.Printf("Hello, %s!\n", n)
})
 
empty := None[string]()
fmt.Println(empty.OrElse("anonymous")) // "anonymous"

type Entity interface {
    GetID() string
}
 
type Repository[T Entity] interface {
    FindByID(id string) (T, error)
    FindAll() ([]T, error)
    Save(entity T) error
    Delete(id string) error
}
 
// インメモリ実装
type InMemoryRepo[T Entity] struct {
    mu    sync.RWMutex
    store map[string]T
}
 
func NewInMemoryRepo[T Entity]() *InMemoryRepo[T] {
    return &InMemoryRepo[T]{
        store: make(map[string]T),
    }
}
 
func (r *InMemoryRepo[T]) FindByID(id string) (T, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    entity, ok := r.store[id]
    if !ok {
        var zero T
        return zero, fmt.Errorf("entity %s not found", id)
    }
    return entity, nil
}
 
func (r *InMemoryRepo[T]) FindAll() ([]T, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    result := make([]T, 0, len(r.store))
    for _, entity := range r.store {
        result = append(result, entity)
    }
    return result, nil
}
 
func (r *InMemoryRepo[T]) Save(entity T) error {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.store[entity.GetID()] = entity
    return nil
}
 
func (r *InMemoryRepo[T]) Delete(id string) error {
    r.mu.Lock()
    defer r.mu.Unlock()
    if _, ok := r.store[id]; !ok {
        return fmt.Errorf("entity %s not found", id)
    }
    delete(r.store, id)
    return nil
}
 
// FindBy は条件に一致するエンティティを検索する
func (r *InMemoryRepo[T]) FindBy(pred func(T) bool) []T {
    r.mu.RLock()
    defer r.mu.RUnlock()
    var result []T
    for _, entity := range r.store {
        if pred(entity) {
            result = append(result, entity)
        }
    }
    return result
}
 
// 使用例
type User struct {
    ID   string
    Name string
    Age  int
}
 
func (u User) GetID() string { return u.ID }
 
repo := NewInMemoryRepo[User]()
repo.Save(User{ID: "1", Name: "Alice", Age: 30})
repo.Save(User{ID: "2", Name: "Bob", Age: 25})
user, _ := repo.FindByID("1")
 
// 条件検索
adults := repo.FindBy(func(u User) bool { return u.Age >= 18 })

// Page はページネーション結果を表す
type Page[T any] struct {
    Items      []T `json:"items"`
    Total      int `json:"total"`
    Page       int `json:"page"`
    PageSize   int `json:"page_size"`
    TotalPages int `json:"total_pages"`
    HasNext    bool `json:"has_next"`
    HasPrev    bool `json:"has_prev"`
}
 
// Paginate はスライスをページネーションする
func PaginateT any Page[T] {
    total := len(items)
    totalPages := (total + pageSize - 1) / pageSize
 
    if page < 1 {
        page = 1
    }
    if page > totalPages && totalPages > 0 {
        page = totalPages
    }
 
    start := (page - 1) * pageSize
    end := start + pageSize
    if start > total {
        start = total
    }
    if end > total {
        end = total
    }
 
    return Page[T]{
        Items:      items[start:end],
        Total:      total,
        Page:       page,
        PageSize:   pageSize,
        TotalPages: totalPages,
        HasNext:    page < totalPages,
        HasPrev:    page > 1,
    }
}
 
// 使用例
users := getAllUsers() // []User
page := Paginate(users, 2, 10) // 2ページ目、1ページ10件
fmt.Printf("Page %d/%d, %d items\n", page.Page, page.TotalPages, len(page.Items))

// Cache はTTL付きのジェネリックキャッシュ
type Cache[K comparable, V any] struct {
    mu      sync.RWMutex
    items   map[K]cacheItem[V]
    ttl     time.Duration
    maxSize int
}
 
type cacheItem[V any] struct {
    value     V
    expiresAt time.Time
}
 
func NewCacheK comparable, V any *Cache[K, V] {
    return &Cache[K, V]{
        items:   make(map[K]cacheItem[V]),
        ttl:     ttl,
        maxSize: maxSize,
    }
}
 
func (c *Cache[K, V]) Get(key K) (V, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
 
    item, ok := c.items[key]
    if !ok || time.Now().After(item.expiresAt) {
        var zero V
        return zero, false
    }
    return item.value, true
}
 
func (c *Cache[K, V]) Set(key K, value V) {
    c.mu.Lock()
    defer c.mu.Unlock()
 
    // maxSize を超えたら期限切れのアイテムを削除
    if len(c.items) >= c.maxSize {
        c.evictExpired()
    }
 
    c.items[key] = cacheItem[V]{
        value:     value,
        expiresAt: time.Now().Add(c.ttl),
    }
}
 
func (c *Cache[K, V]) Delete(key K) {
    c.mu.Lock()
    defer c.mu.Unlock()
    delete(c.items, key)
}
 
func (c *Cache[K, V]) evictExpired() {
    now := time.Now()
    for k, item := range c.items {
        if now.After(item.expiresAt) {
            delete(c.items, k)
        }
    }
}
 
// GetOrLoad はキャッシュに値がなければloader関数で取得してキャッシュする
func (c *Cache[K, V]) GetOrLoad(key K, loader func(K) (V, error)) (V, error) {
    if val, ok := c.Get(key); ok {
        return val, nil
    }
 
    val, err := loader(key)
    if err != nil {
        var zero V
        return zero, err
    }
 
    c.Set(key, val)
    return val, nil
}
 
// 使用例
userCache := NewCachestring, *User
user, err := userCache.GetOrLoad("user-123", func(id string) (*User, error) {
    return db.FindUser(id)
})

import "slices"
 
// ソート
nums := []int{3, 1, 4, 1, 5, 9, 2, 6}
slices.Sort(nums) // [1, 1, 2, 3, 4, 5, 6, 9]
 
// カスタムソート
type User struct {
    Name string
    Age  int
}
users := []User{{"Charlie", 30}, {"Alice", 25}, {"Bob", 35}}
slices.SortFunc(users, func(a, b User) int {
    return cmp.Compare(a.Age, b.Age)
})
// [{Alice 25}, {Charlie 30}, {Bob 35}]
 
// 安定ソート（同じキーの要素の順序を保持）
slices.SortStableFunc(users, func(a, b User) int {
    return cmp.Compare(a.Name, b.Name)
})
 
// 二分探索
sorted := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
idx, found := slices.BinarySearch(sorted, 5) // 4, true
 
// 含有チェック
slices.Contains([]string{"a", "b", "c"}, "b") // true
 
// 最大・最小
slices.Max([]int{3, 1, 4, 1, 5}) // 5
slices.Min([]int{3, 1, 4, 1, 5}) // 1
 
// コンパクト（連続する重複を除去）
nums = []int{1, 1, 2, 3, 3, 3, 4}
slices.Compact(nums) // [1, 2, 3, 4]
 
// リバース
slices.Reverse([]int{1, 2, 3}) // [3, 2, 1]
 
// インデックス検索
slices.Index([]string{"a", "b", "c"}, "b") // 1
 
// 等値比較
slices.Equal([]int{1, 2, 3}, []int{1, 2, 3}) // true
 
// クローン
original := []int{1, 2, 3}
cloned := slices.Clone(original) // ディープコピー

import "maps"
 
m := map[string]int{"a": 1, "b": 2, "c": 3}
 
// キー一覧
keys := maps.Keys(m) // イテレータを返す（Go 1.23+）
 
// 値一覧
values := maps.Values(m) // イテレータを返す
 
// クローン
cloned := maps.Clone(m) // 浅いコピー
 
// 等値比較
maps.Equal(m, cloned) // true
 
// コピー（dstにsrcをマージ）
dst := map[string]int{"a": 10, "d": 4}
maps.Copy(dst, m) // dst = {"a": 1, "b": 2, "c": 3, "d": 4}
 
// 条件による削除
maps.DeleteFunc(m, func(k string, v int) bool {
    return v < 2
})
// m = {"b": 2, "c": 3}

import "cmp"
 
// 比較
cmp.Compare(1, 2)     // -1
cmp.Compare(2, 2)     //  0
cmp.Compare(3, 2)     //  1
 
// ゼロ値チェック
cmp.Or(0, 42)         // 42（最初の非ゼロ値）
cmp.Or("", "default") // "default"
cmp.Or("hello", "default") // "hello"
 
// 複数フォールバック
cmp.Or("", "", "fallback") // "fallback"
 
// ソートキーの合成
type Employee struct {
    Department string
    Name       string
    Salary     int
}
 
employees := []Employee{...}
slices.SortFunc(employees, func(a, b Employee) int {
    // まず部門でソート、同じなら名前でソート
    if c := cmp.Compare(a.Department, b.Department); c != 0 {
        return c
    }
    return cmp.Compare(a.Name, b.Name)
})

// インターフェース版
func SumInterface(nums []interface{}) int {
    sum := 0
    for _, n := range nums {
        sum += n.(int)
    }
    return sum
}
 
// ジェネリック版
func SumGenericT Number T {
    var sum T
    for _, n := range nums {
        sum += n
    }
    return sum
}
 
// 具体型版
func SumInt(nums []int) int {
    sum := 0
    for _, n := range nums {
        sum += n
    }
    return sum
}
 
// ベンチマーク
func BenchmarkSumInterface(b *testing.B) {
    nums := make([]interface{}, 1000)
    for i := range nums { nums[i] = i }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        SumInterface(nums)
    }
}
 
func BenchmarkSumGeneric(b *testing.B) {
    nums := make([]int, 1000)
    for i := range nums { nums[i] = i }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        SumGeneric(nums)
    }
}
 
func BenchmarkSumConcrete(b *testing.B) {
    nums := make([]int, 1000)
    for i := range nums { nums[i] = i }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        SumInt(nums)
    }
}
 
// 典型的な結果:
// BenchmarkSumInterface-8   500000  2800 ns/op  0 B/op  0 allocs/op
// BenchmarkSumGeneric-8    2000000   600 ns/op  0 B/op  0 allocs/op
// BenchmarkSumConcrete-8   2000000   580 ns/op  0 B/op  0 allocs/op
// → ジェネリクスは具体型とほぼ同等、interfaceより大幅に高速

// NG: ジェネリクスが不要なケース
func PrintValueT any {
    fmt.Println(v) // any なら interface{} で十分
}
 
// OK: interface{} または any を直接使う
func PrintValue(v any) {
    fmt.Println(v)
}
 
// NG: 型パラメータが1つの具体型にしか使われない
func ParseUserJSONT User (T, error) {
    var result T
    err := json.Unmarshal(data, &result)
    return result, err
}
 
// OK: 具体型を直接使う
func ParseUserJSON(data []byte) (User, error) {
    var user User
    err := json.Unmarshal(data, &user)
    return user, err
}

// NG: 制約が複雑すぎて可読性が低い
type ComplexConstraint[K comparable, V interface {
    ~int | ~string
    fmt.Stringer
    encoding.BinaryMarshaler
}] struct {
    data map[K]V
}
 
// OK: 制約を分離して名前をつける
type Serializable interface {
    fmt.Stringer
    encoding.BinaryMarshaler
}
 
type ValueType interface {
    ~int | ~string
    Serializable
}
 
type Store[K comparable, V ValueType] struct {
    data map[K]V
}

// NG: ジェネリクスで振る舞いの切り替え
func ProcessT Animal string {
    // T の具体型によって処理を変えたい
    // → ジェネリクスでは型に基づくディスパッチはできない
}
 
// OK: インターフェースを使う
type Animal interface {
    Speak() string
}
 
func Process(a Animal) string {
    return a.Speak()
}

// NG: ジェネリックなゼロ値チェック
func IsZeroT any bool {
    // any にはゼロ値比較の演算がない → コンパイルエラー
    return v == T{} // 不可
}
 
// OK: comparable 制約を使う
func IsZeroT comparable bool {
    var zero T
    return v == zero
}
 
// OK: reflect を使う（any の場合）
func IsZeroAny(v any) bool {
    return reflect.ValueOf(v).IsZero()
}

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md