Generics (zilizoongezwa katika Go 1.18) zinakuruhusu kuandika functions na aina zinazofanya kazi na aina nyingi kupitia type parameters, huku zikidumisha usalama wa aina wakati wa compile. Zinaondoa biashara ya zamani ya ama kurudia msimbo kwa kila aina au kupoteza usalama na 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"
[T constraints.Ordered] hutangaza type parameter T yenye constraint (aina zipi zinaruhusiwa). Compiler hutambua T kutoka kwa hoja — utekelezaji mmoja hufanya kazi kwa aina nyingi, salama kabisa kwa aina.
// 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 hufafanua operesheni zipi ni halali kwenye type parameter (~ inamaanisha "aina yoyote ambayo aina yake ya msingi ni hii").
// 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 zilikuwa nyongeza kubwa, iliyosubiriwa kwa muda mrefu kwa Go (1.18) iliyotatua eneo halisi la maumivu: kabla yake, kuandika msimbo unaoweza kutumika tena kwa aina nyingi kulikulazimisha ama kuurudia kwa kila aina (mrefu, usioweza kudumishwa) au kutumia interface{} (kupoteza usalama wa aina wakati wa compile na kuhitaji assertions za wakati wa utekelezaji).
Generics zinakuruhusu kuandika functions na miundo ya data salama kwa aina, inayoweza kutumika tena (containers, vifaa vya makusanyo kama Map/Filter/Reduce) mara moja, na compiler ikilazimisha usahihi na kutambua aina.
Kuelewa type parameters, constraints (ikijumuisha any, comparable, na sintaksia ya union/~), na aina za generic kunazidi kuwa muhimu kadiri mfumo wa ekolojia unavyozipokea.
Muhimu vile vile ni mtazamo wa Go kwamba generics ni kifaa cha matumizi tena ya kweli, si chaguo-msingi — kuzitumia kupita kiasi kunapinga falsafa ya urahisi ya Go.
Hii ni mada ya sasa, inayojadiliwa mara kwa mara inayoonyesha ufasaha na Go ya kisasa.