Go میں generics کیسے کام کرتے ہیں؟

Question

Accepted Answer

**Generics** (Go 1.18 میں شامل ہوئے) آپ کو ایسے functions اور types لکھنے دیتے ہیں جو type parameters کے ذریعے **متعدد types** کے ساتھ کام کرتے ہیں، جبکہ compile-time type safety برقرار رکھتے ہیں۔ یہ پرانے trade-off کو ختم کرتے ہیں جہاں یا تو ہر type کے لیے کوڈ duplicate کرنا پڑتا تھا یا `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` کا اعلان کرتا ہے جس کے ساتھ ایک **constraint** ہوتی ہے (کون سے types کی اجازت ہے)۔ compiler arguments سے `T` کا اندازہ لگاتا ہے — ایک 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 یہ متعین کرتی ہیں کہ type parameter پر کون سے operations درست ہیں (`~` کا مطلب ہے "کوئی بھی 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 کوڈ لکھنا آپ کو مجبور کرتا تھا کہ یا تو اسے ہر type کے لیے duplicate کریں (لمبا، ناقابلِ برقراری) یا `interface{}` استعمال کریں (compile-time type safety کھو دیں اور runtime assertions کی ضرورت پڑے)۔

Generics آپ کو type-safe، reusable functions اور data structures (containers، Map/Filter/Reduce جیسی collection utilities) ایک بار لکھنے دیتے ہیں، جہاں compiler درستگی کو نافذ کرتا ہے اور types کا اندازہ لگاتا ہے۔

type parameters، constraints (بشمول `any`، `comparable`، اور union/`~` syntax)، اور generic types کو سمجھنا تیزی سے اہم ہوتا جا رہا ہے کیونکہ ecosystem انہیں اپنا رہا ہے۔

اتنا ہی اہم Go کی سوچ ہے کہ generics **حقیقی reuse کے لیے ایک ٹول ہیں، کوئی default نہیں** — انہیں حد سے زیادہ استعمال کرنا Go کے سادگی کے فلسفے کے خلاف کام کرتا ہے۔

یہ ایک حالیہ، اکثر زیرِ بحث موضوع ہے جو جدید Go کے ساتھ مہارت کی عکاسی کرتا ہے۔