Go ਵਿੱਚ generics ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

**Generics** (Go 1.18 ਵਿੱਚ ਜੋੜੇ ਗਏ) ਤੁਹਾਨੂੰ functions ਅਤੇ types ਲਿਖਣ ਦਿੰਦੇ ਹਨ ਜੋ **ਕਈ types** ਨਾਲ type parameters ਰਾਹੀਂ ਕੰਮ ਕਰਦੇ ਹਨ, ਜਦਕਿ compile-time type safety ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦੇ ਹਨ। ਇਹ ਪੁਰਾਣੀ trade-off ਨੂੰ ਖਤਮ ਕਰਦੇ ਹਨ: ਜਾਂ ਤਾਂ ਹਰ type ਲਈ code ਨੂੰ ਡੁਪਲਿਕੇਟ ਕਰਨਾ ਜਾਂ `interface{}` ਨਾਲ safety ਗੁਆਉਣਾ।

## 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` ਨੂੰ declare ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕ **constraint** ਹੈ (ਕਿਹੜੀਆਂ types allowed ਹਨ)। Compiler arguments ਤੋਂ `T` ਨੂੰ infer ਕਰਦਾ ਹੈ — ਇੱਕ implementation ਕਈ types ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ, ਪੂਰੀ ਤਰ੍ਹਾਂ 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 define ਕਰਦੇ ਹਨ ਕਿ type parameter ਉੱਤੇ ਕਿਹੜੇ operations valid ਹਨ (`~` ਦਾ ਮਤਲਬ ਹੈ "ਕੋਈ ਵੀ type ਜਿਸ ਦੀ underlying type ਇਹ ਹੈ")।

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

## ਕਦੋਂ 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) ਵਿੱਚ ਇੱਕ ਵੱਡਾ, ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਇੰਤਜ਼ਾਰ ਕਰਿਆ ਗਿਆ ਸੰਯੋਜਨ ਸੀ ਜੋ ਇੱਕ ਅਸਲ ਪੀੜਾ ਬਿੰਦੂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਸੀ: ਇਨ੍ਹਾਂ ਤੋਂ ਪਹਿਲਾਂ, ਕਈ types ਲਈ reusable code ਲਿਖਣਾ ਤੁਹਾਨੂੰ ਜਾਂ ਤਾਂ ਹਰ type ਲਈ ਇਸ ਨੂੰ duplicate ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਸੀ (verbose, unmaintainable) ਜਾਂ `interface{}` ਦੀ ਵਰਤੋਂ ਕਰਨਾ (compile-time type safety ਗੁਆਉਂਦਿਆਂ ਅਤੇ runtime assertions ਦੀ ਲੋੜ ਕਰਦਿਆਂ)।

Generics ਤੁਹਾਨੂੰ type-safe, reusable functions ਅਤੇ data structures (containers, collection utilities ਜਿਵੇਂ Map/Filter/Reduce) ਇੱਕ ਵਾਰ ਲਿਖਣ ਦਿੰਦੇ ਹਨ, compiler correctness ਨੂੰ enforce ਕਰਦੇ ਹਾਂ ਅਤੇ types infer ਕਰਦੇ ਹਾਂ।

Type parameters, constraints (`any`, `comparable`, ਅਤੇ union/`~` syntax ਸਮੇਤ), ਅਤੇ generic types ਨੂੰ ਸਮਝਣਾ ਅਲੋਪ ਹੋ ਰਿਹਾ ਹੈ ਕਿਉਂਕਿ ecosystem ਇਨ੍ਹਾਂ ਨੂੰ adopt ਕਰ ਰਹੇ ਹਨ।
rabar ਹੀ ਮਹੱਤਵਪੂਰਨ Go mentality ਹੈ ਕਿ generics ਇੱਕ **ਅਸਲ reuse ਲਈ tool ਹੈ, default ਨਹੀਂ** — ਇਨ੍ਹਾਂ ਦੀ overuse Go ਦੀ simplicity philosophy ਦੇ ਵਿਰੁੱਧ ਕੰਮ ਕਰਦੀ ਹੈ।

ਇਹ ਇੱਕ ਮੌਜੂਦਾ, ਆਪਣੇ ਆਪ ਵਿੱਚ ਬਿੱਤ ਕੀਤਾ ਜਾ ਰਿਹਾ ਵਿਸ਼ਾ ਹੈ ਜੋ modern Go ਦੇ ਨਾਲ fluency ਨੂੰ ਪ੍ਰਤੀਬਿੰਬਿਤ ਕਰਦਾ ਹੈ।