Go-ல் generics எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

**Generics** (Go 1.18-ல் சேர்க்கப்பட்டது) type parameters மூலம் **பல வகைகளுடன்** செயல்படும் functions மற்றும் types எழுத உங்களை அனுமதிக்கிறது, compile-time type safety-ஐ பராமரித்தபடி. இது `interface{}` கொண்டு ஒவ்வொரு வகைக்கும் code duplicate செய்யுவதோ அல்லது safety இழப்பதோ என்ற பழைய compromise-ஐ நீக்குகிறது.

## 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 function

```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 arguments இலிருந்து `T`-ஐ infer செய்கிறது — ஒரு implementation பல வகைகளுக்கு வேலை செய்கிறது, முழு type-safe.

## Type constraints

```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.
```

Constraints என்பது type parameter-ல் என்ன operations செல்லுபடி ஆகும் என்பதை வரையறுக்கிறது (`~` என்பது "அடிப்படை வகை இது என்ற எந்த வகை")

## Generic types

```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
```

## எப்போது use செய்ய வேண்டும் (மற்றும் செய்ய வேண்டாம்)

```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) ஆகும், இது ஒரு உண்மையான வலி புள்ளிமுன்னை தீர்த்தது: அதற்கு முன், பல வகைகளுக்கு reusable code எழுதுவது ஒவ்வொரு வகைக்கும் duplicate செய்வதை (verbose, unmaintainable) அல்லது `interface{}` use செய்வதை (compile-time type safety இழந்து, runtime assertions தேவைப்பட்டது) கட்டாயப்படுத்தியது.

Generics என்பது type-safe, reusable functions மற்றும் data structures (containers, Map/Filter/Reduce போன்ற collection utilities) ஒரு முறை எழுத உங்களை அனுமதிக்கிறது, compiler correctness-ஐ enforce செய்து types-ஐ infer செய்கிறது.

Type parameters, constraints (including `any`, `comparable`, மற்றும் union/`~` syntax), மற்றும் generic types ஆகியவற்றைப் புரிந்துகொள்வது ecosystem அவற்றை adopt செய்கிறபோது점차 முக்கியமாகிறது.

சமान அளவில் முக்கியம் என்பது Go mindset ஆகும், generics என்பது **உண்மையான reuse-ற்கான ஒரு tool, default அல்ல** — அவற்றை overuse செய்வது Go-ற்கான simplicity philosophy-க்கு எதிராக செயல்படுகிறது.

இது ஒரு current, frequently-discussed topic ஆகும், modern Go-உடன் fluency-ஐ பிரதிபலிக்கிறது.