Go-లో జెనెరిక్‌లు ఎలా పని చేస్తాయి?

Question

Accepted Answer

**జెనెరిక్‌లు** (Go 1.18లో జోడించబడ్డాయి) టైప్ పారామీటర్ల ద్వారా **బహుళ రకాలతో** పని చేసే ఫంక్షన్‌లు మరియు రకాలను వ్రాయడానికి మీకు అనుమతి ఇస్తాయి, సంకలన సమయంలో టైప్ సేఫ్టీని నిలుపుకుంటూ. అవి ప్రతి రకానికి కోడ్‌ను నకిలీ చేయడం లేదా `interface{}`తో సేఫ్టీని కోల్పోయే పాత ట్రేడ్‌ఆఫ్‌ను తొలగిస్తాయి.

## జెనెరిక్‌లు పరిష్కరించే సమస్య

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

## ఒక జెనెరిక్ ఫంక్షన్

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

నిర్బంధాలు టైప్ పారామీటర్‌పై ఏ ఆపరేషన్‌లు చెల్లుబాటు అయ్యేవో నిర్వచించాయి (`~` అంటే "ఈ అంతర్లీన రకమైన ఏదైనా రకం").

## జెనెరిక్ రకాలు

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

## ఎప్పుడు ఉపయోగించాలి (మరియు చేయవద్దు)

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

## ఇది ఎందుకు ముఖ్యమైనది

జెనెరిక్‌లు Go (1.18)కు ఒక ప్రధాన, చాలాకాలం నుండి ఆశించిన చేర్పు, ఇది ఒక నిజమైన నొప్పి బిందువును పరిష్కరించింది: వాటికి ముందు, బహుళ రకాలకు పునర్ వినియోగయోగ్య కోడ్‌ను వ్రాయడం ఆपনను ప్రతి రకానికి నకిలీ చేయవలసి ఉంది (వర్బోస్, నిర్వహించలేనిది) లేదా `interface{}`ను ఉపయోగించవలసి ఉంది (సంకలన సమయానికి టైప్ సేఫ్టీని కోల్పోయే మరియు రన్‌టైమ్ ఆల్‌పర్శన్‌ల అవసరం).

జెనెరిక్‌లు టైప్-సేఫ్, పునర్ వినియోగయోగ్య ఫంక్షన్‌లు మరియు డేటా స్ట్రక్చర్‌లు (కంటైనర్‌లు, Map/Filter/Reduce వంటి సంగ్రహణ సేవలు) ఒక్కసారి వ్రాయడానికి అనుమతిస్తాయి, కంపైలర్ సరిదిద్దుకోవడాన్ని ఖచ్చితంగా చేస్తుంది మరియు రకాలను అనుమానించటానికి.

టైప్ పారామీటర్‌లు, నిర్బంధాలు (`any`, `comparable`, మరియు union/`~` సింటాక్స్‌ను కలిగిన), మరియు జెనెరిక్ రకాలను అర్థం చేసుకోవడం ఎకోసిస్టం వాటిని స్వీకరించటానికి సున్నితంగా పెరుగుతోంది.

సమానంగా ముఖ్యమైనది జెనెరిక్‌లు ఒక **నిజమైన పునర్ వినియోగం కోసం సాధనం, డిఫాల్ట్ కాదు** అనే Go మానసిక దృష్టిభంగి — వాటిని అధిక ఉపయోగం Go యొక్క సరళత తత్త్వానికి వ్యతిరేకంగా పనిచేస్తుంది.

ఇది ఆధુనిక Go తో నిష్ణాతత్వాన్ని ప్రతిబింబించే ప్రస్తుత, తరచుగా-చర్చించిన విషయం.