Generics: เขียนครั้งเดียว ใช้ได้หลาย type

1 · ปัญหา: สองทางที่แย่ทั้งคู่

func SumInts(values []int) int {
    var total int
    for _, v := range values {
        total += v
    }
    return total
}

func SumFloat64s(values []float64) float64 {
    var total float64
    for _, v := range values {
        total += v
    }
    return total
}

func Sum(values []any) any {
    var total any
    for _, value := range values {
        switch v := value.(type) {
        case int:
            total = total.(int) + v
        case float64:
            total = total.(float64) + v
        }
    }
    return total
}

fmt.Println(Sum([]any{1, 2, 3}))

panic: interface conversion: interface {} is nil, not int

2 · ทางที่สาม: type parameter

อ่าน Number ให้ออกก่อน — ข้างในไม่ใช่รายชื่อ method แต่เป็น "รายชื่อ type ที่ยอมรับ" เครื่องหมาย | อ่านว่า "หรือ" (เป็น int ก็ได้ int64 ก็ได้ float64 ก็ได้) ส่วน ~ ข้างหน้าอ่านว่า "type ใดก็ตามที่มี underlying type เป็นตัวนี้" ซึ่งทำให้ type ที่คุณตั้งเองอย่าง type Score int ผ่านด่านไปด้วย
ตอนนี้จำแค่นี้พอ — หัวข้อ 7 จะรันให้ดูว่าถ้าลืม ~ แล้ว compiler ด่าว่าอะไร

type Number interface {
    ~int | ~int64 | ~float64
}

func Sum[T Number](values []T) T {
    var total T          // zero value ของ T = 0 ไม่ใช่ nil
    for _, value := range values {
        total += value    // compiler รู้ว่า T บวกกันได้
    }
    return total
}

ints   := Sum([]int{10, 20, 30})       // 60
floats := Sum([]float64{1.5, 2.5, 3.5})  // 7.5

  ตำแหน่งของวงเล็บบอกว่าเป็นอะไร

  func Sum [T Number] (values []T) T
           ─────┬─────   ────┬────    ┬
                │            │        └─ คืนค่าเป็น type เดียวกัน
                │            └────────── parameter ปกติ ใช้ T ได้
                └─────────────────────── type parameter
                                         "T คือ type อะไรก็ได้ที่เข้าเกณฑ์ Number"

  [] เหลี่ยม = ส่ง type เข้าไป   ·   () กลม = ส่ง ค่า เข้าไป

3 · [T any] ไม่เหมือน parameter ที่เป็น any

จุดนี้คนสับสนมากที่สุด เพราะคำว่า any โผล่ทั้งสองแบบ แต่ความหมายคนละเรื่อง:

func Identity(value any) any {
    return value
}

name := Identity("Alice")

// name เป็น any → ใช้กับ string ไม่ได้
fmt.Println(strings.ToUpper(
    name.(string),  // ต้อง assert เอง
))

func Identity[T any](value T) T {
    return value
}

name := Identity("Alice")

// name เป็น string เต็มตัว
fmt.Println(strings.ToUpper(name))

4 · comparable — เกณฑ์สำหรับของที่เทียบกันได้

any กว้างเกินไปสำหรับงานที่ต้องใช้ == Go มีเกณฑ์สำเร็จรูปให้ชื่อ comparable:

func Contains[T comparable](values []T, target T) bool {
    for _, value := range values {
        if value == target {   // ใช้ == ได้เพราะ comparable
            return true
        }
    }
    return false
}

Contains([]int{10, 20, 30}, 20)                  // true
Contains([]string{"Go", "Java"}, "Go")            // true
Contains(points, Coordinate{X: 10, Y: 20})       // true — struct ที่ทุก field เทียบได้

ที่ใช้บ่อยอีกที่คือ key ของ map — เพราะ Go บังคับอยู่แล้วว่า key ต้องเทียบได้:

func Keys[K comparable, V any](items map[K]V) []K {
    keys := make([]K, 0, len(items))
    for key := range items {
        keys = append(keys, key)
    }
    return keys
}

5 · Type inference — ไม่ต้องบอก type ก็ได้

type inference = "compiler เดา type ให้เอง" · คุณส่ง []int เข้าไป มันก็รู้เองว่า T คือ int ไม่ต้องพิมพ์บอกซ้ำ

// แบบกำหนดเอง — ชัดเจนแต่ยาว
Contains[int]([]int{10, 20, 30}, 20)

// แบบให้ compiler เดาเอาจาก argument — นิยมกว่า
Contains([]int{10, 20, 30}, 20)

ส่วนใหญ่เขียนแบบสั้นได้เลย
จะต้องระบุเองก็ต่อเมื่อ compiler เดาไม่ออก — คือกรณีที่ T ไม่ได้โผล่ใน argument ที่ส่งเข้าไปเลย มีแต่ใน return type พอไม่มีอะไรให้ดู มันก็เดาไม่ถูก

6 · Constraint — กำหนดว่า T ต้องทำอะไรได้บ้าง

constraint คือ "เกณฑ์" ที่บอกว่า T ต้องเป็น type แบบไหนถึงจะผ่าน
ทีนี้ [T any] แปลว่า "อะไรก็ได้" ซึ่งแปลว่าไม่มีเกณฑ์อะไรเลย ผลคือ compiler ไม่ยอมให้คุณทำอะไรกับมัน นอกจากส่งต่อ — เพราะมันไม่มีทางรับประกันได้ว่าของที่ส่งเข้ามาบวกกันได้:

func Sum[T any](values []T) T {
    var total T
    for _, value := range values {
        total += value   // ❌ compile error — T อาจเป็น struct ที่บวกไม่ได้
    }
    return total
}

วิธีแก้คือบอก compiler ว่า T แคบลงแค่ไหน — เขียนเป็น interface ที่ระบุรายชื่อ type แทนรายชื่อ method:

import "cmp"

func Min[T cmp.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

Min(10, 20)            // 10
Min(1.5, 2.5)          // 1.5
Min("apple", "zoo")   // apple — string เรียงได้เหมือนกัน

7 · ~ — สัญลักษณ์ที่ทำให้ custom type ผ่านด่าน

type Integer interface { int | int64 }   // ← ไม่มี ~

func Max[T Integer](a, b T) T {
    if a > b { return a }
    return b
}

type Score int          // จากบทเรียน 09

var first  Score = 80
var second Score = 95
fmt.Println(Max(first, second))

Score does not satisfy Integer (possibly missing ~ for int in Integer)

type Integer interface { ~int | ~int64 }
// ~int อ่านว่า "type ใดก็ตามที่มี underlying type เป็น int"
// → int ผ่าน · Score ผ่าน · Temperature ผ่าน · UserID ผ่าน

  int  กับ  ~int  ต่างกันตรงนี้

   type Score int          type Temperature int        int
        │                        │                      │
        └── underlying: int ─────┴──── underlying: int ─┘
                                 │
              ┌──────────────────┴──────────────────┐
              │                                     │
      constraint  int                      constraint  ~int
      รับเฉพาะตัวขวาสุด                      รับทั้งสามตัว
      (Score, Temperature ตกด่าน)            (ผ่านหมด)

ใช้ได้กับ slice type ที่ตั้งเองด้วย:

type Names []string

type StringSlice interface { ~[]string }

func CountNames[S StringSlice](names S) int {
    return len(names)
}

CountNames([]string{"Alice", "Bob"})   // ผ่าน
CountNames(Names{"Alice", "Bob"})        // ผ่านเพราะมี ~

ทดสอบความเข้าใจ

invalid operation: value > best (type parameter T cannot use operator >)

อ้างอิง

• Tutorial: Getting started with generics — ทางการ เริ่มจาก Sum แบบเดียวกับบทนี้
• An Introduction To Generics — Go Blog ตอนปล่อย Go 1.18
• Go Spec — Type parameter declarations — ตัวบทกฎหมายเรื่อง ~ และ type set
• pkg.go.dev — cmp.Ordered
• Go maps in action — ที่มาของการสุ่มลำดับ for range บน map