generics ใน Go ทำงานอย่างไร?

Question

Accepted Answer

**generics** (เพิ่มเข้ามาใน Go 1.18) ช่วยให้คุณเขียนฟังก์ชันและชนิดที่ทำงานกับ **หลายชนิด** ผ่าน type parameter ในขณะที่ยังคงความปลอดภัยด้านชนิดตอน compile time มันกำจัดทางเลือกแบบเดิมที่ต้องเลือกระหว่างการเขียนโค้ดซ้ำต่อแต่ละชนิด หรือสูญเสียความปลอดภัยด้วย `interface{}`

## ปัญหาที่ generics แก้

```go
// ❌ before generics — either duplicate per type...
func MaxInt(a, b int) int { ... }
func MaxFloat(a, b float64) float64 { ... }   // copy-paste for each type

// ...or use interface{} and lose type safety + need casts/assertions
func Max(a, b interface{}) interface{} { ... }   // unsafe, clunky
```

## ฟังก์ชันแบบ generic

```go
// T is a type parameter constrained to be "ordered" (comparable with < >)
func Max[T constraints.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}

Max(3, 5)         // T inferred as int → 5
Max(2.5, 1.1)     // T inferred as float64 → 2.5
Max("a", "b")     // T inferred as string → "b"
```

`[T constraints.Ordered]` ประกาศ type parameter `T` พร้อม **constraint** (ว่าชนิดใดบ้างที่อนุญาต) compiler จะอนุมาน `T` จากอาร์กิวเมนต์ — โค้ด implementation เดียวทำงานได้กับหลายชนิด โดยปลอดภัยด้านชนิดอย่างสมบูรณ์

## type constraint

```go
// a constraint is an interface listing allowed types or required methods
type Number interface {
    ~int | ~int64 | ~float64        // the | union means "any of these"
}

func Sum[T Number](nums []T) T {
    var total T
    for _, n := range nums {
        total += n                   // safe — T is constrained to numeric types
    }
    return total
}
Sum([]int{1, 2, 3})       // 6
Sum([]float64{1.5, 2.5})  // 4.0

// built-in constraints:
any                        // any type (alias for interface{})
comparable                 // types usable with == (for map keys, etc.)
// golang.org/x/exp/constraints: Ordered, Integer, Float, etc.
```

constraint กำหนดว่าการดำเนินการใดที่ใช้ได้กับ type parameter (`~` หมายถึง "ชนิดใด ๆ ที่มี underlying type เป็นชนิดนี้")

## ชนิดแบบ generic

```go
// a generic stack that works for any type
type Stack[T any] struct {
    items []T
}
func (s *Stack[T]) Push(item T) { s.items = append(s.items, item) }
func (s *Stack[T]) Pop() T {
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item
}

intStack := Stack[int]{}       // a stack of ints
strStack := Stack[string]{}     // a stack of strings — same code
```

## เมื่อใดควรใช้ (และไม่ควรใช้) generics

```text
✓ Generic data structures (stacks, trees, sets), utility functions over collections
  (Map, Filter, Reduce), type-safe containers
✗ Don't overuse — if interfaces or a concrete type work simply, prefer them.
  Go's philosophy still favors simplicity; generics are a tool, not a default.
```

## ทำไมจึงสำคัญ

generics เป็นการเพิ่มเข้ามาครั้งสำคัญที่รอคอยมานานของ Go (1.18) ที่แก้จุดเจ็บปวดที่มีอยู่จริง: ก่อนหน้านั้น การเขียนโค้ดที่นำกลับมาใช้ใหม่ได้สำหรับหลายชนิดบังคับให้คุณต้องเลือกระหว่างการเขียนซ้ำต่อแต่ละชนิด (ยืดยาว ดูแลยาก) หรือใช้ `interface{}` (สูญเสียความปลอดภัยด้านชนิดตอน compile time และต้องทำ assertion ขณะ runtime)

generics ช่วยให้คุณเขียนฟังก์ชันและโครงสร้างข้อมูลที่ปลอดภัยด้านชนิดและนำกลับมาใช้ใหม่ได้ (container, ฟังก์ชัน utility สำหรับ collection อย่าง Map/Filter/Reduce) เพียงครั้งเดียว โดยที่ compiler บังคับความถูกต้องและอนุมานชนิดให้

การเข้าใจ type parameter, constraint (รวมถึง `any`, `comparable` และไวยากรณ์ union/`~`) และชนิดแบบ generic มีความสำคัญมากขึ้นเรื่อย ๆ เมื่อ ecosystem นำมาใช้

ที่สำคัญไม่แพ้กันคือกรอบความคิดแบบ Go ที่ว่า generics เป็น **เครื่องมือสำหรับการ reuse ที่แท้จริง ไม่ใช่ค่าเริ่มต้น** — การใช้มันมากเกินไปขัดกับปรัชญาความเรียบง่ายของ Go

นี่เป็นหัวข้อร่วมสมัยที่ถูกพูดถึงบ่อย สะท้อนความคล่องกับ Go สมัยใหม่