Conas a oibríonn generics i Go?

Question

Accepted Answer

**Generics** (curtha leis i Go 1.18) a ligint duit feidhmeanna agus cineálacha a scríobh a oibríonn le **go leor cineálacha** trí pharaiméadair cineáil, agus sábháilteacht cineáil ag an am geilleagair a choinneáil. Cuireann siad deireadh leis an tseansocrú idir cód a dhúbláil de réir cineál nó sábháilteacht a chailliúint le `interface{}`.

## An fhadhb a réitítear ag 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
```

## Feidhm ghenereach

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

Tuairisíonn an `[T constraints.Ordered]` paraiméadar cineáil `T` le **srian** (cad iad na cineálacha a bhíonn ceadaithe). Cuireann an compiler `T` i leataobh ó na hargóintí — feidhmíonn feidhm amháin do go leor cineálacha, go hiomlán sábháilte ó thaobh cineáil de.

## Srianta cineáil

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

Saíníonn srianta cad iad na hoibríochtaí a bhíonn bailí ar an paraiméadar cineáil (ciallaíonn an `~` "aon chineál ar a bhfuil an bunúsach cineál seo aige").

## Cineálacha generics

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

## Cathain a úsáid (agus nach) 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.
```

## Cén fáth is tábhachtach é

Bhí generics ina phríomh-bhreisiú fada-bhraistí ar Go (1.18) a réitigh poing fíor-phianta: roimhe sin, cód inúsáidte a scríobh do go leor cineálacha thug air ó dhá rogha amháin — cód a dhúbláil de réir cineál (foclóirí, deacair a choimeád) nó `interface{}` a úsáid (sábháilteacht cineáil a chailliúint agus tuar a dhéanamh ag an am fhritháireamh).

Ligint generics duit feidhmeanna agus struchtúir sonraí sábháilte ó thaobh cineáil de agus inúsáidte (coimeádáin, uirlisí bailiúcháin ar nós Map/Filter/Reduce) a scríobh faoi dhó, agus an compiler ag feidhmiú i ndéantús agus ag tabhairt breis ar chineálacha.

Tá tuiscint ar pharaiméadair cineáil, srianta (lena n-áirítear `any`, `comparable`, agus comhghaoil/`~` syntax), agus cineálacha generics níos tábhachtaí de réir a chéile agus gur ghlacann an timpeallacht leis.

Is ionann atá tábhachtach agus an mothúchán Go go bhfuil generics ina **uirlis do athúsáid dhíreach, ní réamhshocrúchán** — é ró-úsáid a dhéanamh orthu a bheith in aghaidh fealsuintí simplíochta Go.

Is ábhar reatha, fidir-dhóichta ann é seo a léiríonn eagna le Go nua-aimseartha.