func MinInt(a, b int) int { if a < b { return a }; return b }
func MinFloat(a, b float64) float64 { if a < b { return a }; return b }

func Min[T int | float64](a, b T) T {
    if a < b { return a }
    return b
}
Min(1, 2)       // T=int
Min(1.5, 2.5)   // T=float64
Min[int](1, 2)  // เขียนชัดก็ได้

func Map[T, R any](s []T, f func(T) R) []R {
    out := make([]R, 0, len(s))
    for _, v := range s { out = append(out, f(v)) }
    return out
}

type Number interface { ~int | ~int64 | ~float64 }
// ~ = เอา type ที่ไส้เป็น int ด้วย เช่น type Age int ก็ได้

type Node[T Node[T]] interface { Next() T }
// T ต้องเป็น Node เหมือนกัน ไว้ทำ tree/graph

func (r *Rand) N[Int intType](n Int) Int
// เมธอดเดียวใช้ทุก int ไม่ต้องแยก Int32N Int64N

func GenericFormatter[T any](v T) string { return fmt.Sprintf("value: %v", v) }
type IntFormatter func(int) string

formatters := []IntFormatter{GenericFormatter} // เดา T=int
fn := IntFormatter(GenericFormatter)
ch := make(chan IntFormatter, 1)
ch <- GenericFormatter // ส่งเข้า channel ก็เดาให้

func IndexOf[T comparable](xs []T, want T) int {
    for i, x := range xs {
        if x == want {
            return i
        }
    }
    return -1
}

func Sum[T ~int | ~float64](xs []T) T {
    var total T
    for _, x := range xs {
        total += x
    }
    return total
}

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

func (q *Queue[T]) Push(x T) { q.items = append(q.items, x) }
func (q *Queue[T]) Pop() (T, bool) {
    if len(q.items) == 0 {
        var zero T
        return zero, false
    }
    x := q.items[0]
    q.items = q.items[1:]
    return x, true
}