Kako delujejo generiki v Go-u?

Question

Accepted Answer

**Generiki** (dodani v Go 1.18) vam omogočajo pisanje funkcij in tipov, ki delujejo z **več tipi** preko parametrov tipa, pri čemer ohranjate varnost tipov ob času prevajanja. Odpravljajo stari kompromis, pri katerem ste morali bodisi podvajati kodo za vsak tip bodisi izgubiti varnost z `interface{}`.

## Problem, ki ga rešajo generiki

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

## Generična funkcija

```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]` deklarira parameter tipa `T` z **omejitvijo** (katere tipe je dovoljeno uporabljati). Prevajalnik sklepa `T` iz argumentov — ena implementacija deluje za mnogo tipov, popolnoma varno glede tipov.

## Omejitve tipov

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

Omejitve definirajo, katere operacije so veljave na parametru tipa (`~` pomeni "katerikoli tip, katerega osnovni tip je ta").

## Generični tipi

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

## Kdaj uporabljati (in ne) generike

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

## Zakaj je to pomembno

Generiki so bili večja, dolgo pričakivana dodatek k Go-u (1.18), ki je razrešil pravo težavo: pred njimi je pisanje ponovno uporabljive kode za več tipov pomenilo bodisi podvajanje kode za vsak tip (dolgočasno, težko vzdržljivo) bodisi uporabo `interface{}` (izguba varnosti tipov ob času prevajanja in potreba po potrditvah tipov med izvajanjem).

Generiki vam omogočajo, da napišete varno glede tipov in ponovno uporabljive funkcije ter podatkovne strukture (vsebniki, komunalne funkcije zbirk kot Map/Filter/Reduce) le enkrat, pri čemer prevajalnik zagotavlja pravilnost in sklepa tipe.

Razumevanje parametrov tipov, omejitev (vključno s `any`, `comparable` in sintakso unije/`~`) ter generičnih tipov je vedno bolj pomembno, saj ekosistem jih sprejema.

Enako pomembno je Go-ovo razmišljanje, da so generiki **orodje za pristno ponovno uporabo, ne privzeta nastavka** — prekomerna njihova uporaba nasprotuje Go-ovi filozofiji preprostosti.

To je trenutna, pogosto obravnavana tema, ki odraža tekoče znanje sodobnega Go-a.