Go માં generics કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

**Generics** (Go 1.18 માં ઉમેરવામાં આવ્યો) તમને ફંક્શન અને પ્રકારો લખવા દે છે જે **બહુવિધ પ્રકાર** સાથે કાર્ય કરે છે type parameters દ્વારા, જ્યારે compile-time type safety જાળવી રાખી છે. તેઓ કોડને પ્રતિ પ્રકાર ડુપ્લિકેટ કરવાની અથવા `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` દલીલ પરથી અનુમાન કરે છે — એક પ્રમાણીકરણ ઘણા પ્રકાર માટે કાર્ય કરે છે, સંપૂર્ણ 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 (પર કયા ઑપરેશન માન્ય છે (the `~` નો અર્થ "કોઈ પણ પ્રકાર જેનો અંતર્ગત પ્રકાર આ છે").

## 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{}` ઉપયોગ કરો (runtime assertions જરૂરી કર્યા વિના compile-time type safety ગુમાવી દો).

Generics તમને type-safe, પુનઃવપરાશ ફંક્શન અને ડેટા structure (કન્ટેનરો, સંગ્રહ સુવિધાઓ જેમ કે Map/Filter/Reduce) લખવા દે છે એક વાર, compiler સાથે સુધારણા જાણીને અને પ્રકાર અનુમાન કરવું.

Type parameters, constraints (including `any`, `comparable`, અને union/`~` syntax), અને generic પ્રકારોને સમજવું જેમ જેમ ecosystem તેમને અપનાવે છે તેમ તેમ વધુ મહત્વપૂર્ણ બને છે.

સમાન મહત્વપૂર્ણ Go માનસિકતા છે કે generics **વાસ્તવિક પુનઃવપરાશ માટે એક સાધન, ડિફોલ્ટ નહીં** — તેમનો અતિશય ઉપયોગ Go ના simplicity philosophy ની વિરુધ્ધ કાર્ય કરે છે.

યह આધુનિક Go સાથે તરલતા પ્રતિબિંબિત કરતો એક વર્તમાન, વારંવાર-ચર્ચા કરાયેલો વિષય છે.