Generics (Go 1.18 मा थपिएको) ले तपाईलाई एकाधिक types सँग काम गर्ने functions र types लेख्न दिन्छ type parameters मार्फत, compile-time type safety राख्दै। तिनीहरूले पुरानो व्यापार-अफ समाप्त गर्छन् कि या त type प्रति कोड दोहोरिनु पर्छ वा interface{} सँग सुरक्षा गुमाउनु पर्छ।
{ ... }
{ ... }
{} { ... }
// 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"
The [T constraints.Ordered] ले type parameter T लाई declare गर्छ constraint सँग (कुन types अनुमति छन्)। compiler ले arguments बाट T लाई infer गर्छ — एक कार्यान्वयन धेरै types को लागि काम गर्छ, पूर्ण रूपमा type-safe।
// 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 मान्य छन् (the ~ को अर्थ "कुनै पनि type जसको underlying type यो हो")।
// 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
✓ 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 को लागि पुनः प्रयोगयोग्य कोड लेख्न तपाईलाई या त यसलाई type प्रति दोहोरिनु पर्यो (verbose, अरक्षणीय) वा interface{} प्रयोग गर्नु पर्यो (compile-time type safety गुमाउँदै र runtime assertions आवश्यक गर्दै)।
Generics ले तपाईलाई type-safe, पुनः प्रयोगयोग्य functions र data structures (containers, collection utilities जस्तै Map/Filter/Reduce) एक पटक लेख्न दिन्छ, compiler सँग सुधार लागू गरिँदै र types infer गरिँदै।
Type parameters, constraints (including any, comparable, र union/~ syntax लगायत), र generic types बुझ्न गएको ecosystem तिनीहरूलाई अपनाउन थालेको साथ क्रमशः महत्त्वपूर्ण छ।
समान रूपमा महत्त्वपूर्ण हो Go मानसिकता कि generics एक साधन हो वास्तविक पुनः प्रयोगको लागि, default होइन — तिनीहरूलाई अत्यधिक प्रयोग गर्न Go को सरलता दर्शनको विरुद्ध काम गर्छ।
यो हाल को, बारम्बार-छलफल गरिएको विषय हो जो आधुनिक Go सँग प्रवाहशीलता प्रतिफलित गर्छ।