Go मध्ये generics कसे काम करतात?

Question

Accepted Answer

**Generics** (Go 1.18 मध्ये जोडलेले) तुम्हाला टाइप पॅरामीटरद्वारे **एकाधिक प्रकारांसह** काम करणारे फंक्शन्स आणि प्रकार लिहिण्याची परवानगी देतात, तर कंपाइल-टाइम टाइप सेफ्टी राखते. ते पुराने व्यापार-ऑफला दूर करतात: प्रत्येक प्रकारासाठी कोड डुप्लिकेट करा किंवा `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]` टाइप पॅरामीटर `T` **मर्यादा** (कोणते प्रकार परवानगीद आहेत) सह घोषित करते. कंपाइलर `T` गुणांतर अनुमान लगाता — एक अंमलबजावणी अनेक प्रकारांसाठी कार्य करते, पूर्णपणे टाइप-सुरक्षित.

## टाइप मर्यादा

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

मर्यादा परिभाषित करतात की टाइप पॅरामीटरवर कोणसे ऑपरेशन वैध आहेत (`~` म्हणजे "कोणताही प्रकार ज्याचा अंतर्निहित प्रकार हा आहे").

## 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{}` सह टाइप सेफ्टी गमवा आणि रनटाइम अभिजात प्रमाणीकरण आवश्यक आहे) किंवा बाध्य केले गेले.

Generics तुम्हाला टाइप-सुरक्षित, पुन्हा वापरता येणारे फंक्शन्स आणि डेटा स्ट्रक्चर्स (कंटेनर्स, कलेक्शन utilities जसे Map/Filter/Reduce) एकदा लिहू देतात, कंपाइलर सुदृढता लागू करून आणि प्रकार अनुमान लगाता.

टाइप पॅरामीटर्स, मर्यादा (ज्यात `any`, `comparable` आणि union/`~` वाक्यरचना समाविष्ट आहे) आणि generic प्रकार समजून घेणे अधिकाधिक महत्वाचे आहे कारण इकोसिस्टम त्यांना अंगीकार करत आहे.

तेवढेच महत्वाचे म्हणजे Go मानसिकता की generics हे **वास्तविक पुन्हा वापराचे साधन आहे, डिफॉल्ट नाही** — त्यांचा जास्त वापर Go च्या सरलतेच्या तत्वज्ञानाविरुद्ध कार्य करते.

हे एक चालू, वारंवार चर्चा होणारा विषय आहे जो आधुनिक Go सह प्रवाह दर्शवते.