What are generics and type sets in Go?

Question

Accepted Answer

Generics with type sets is a **powerful system** for creating universal code.

```go
// Type set with union
type Signed interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}

type Unsigned interface {
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}

type Integer interface {
    Signed | Unsigned
}

// Function with constraint
func Abs[T Signed](n T) T {
    if n < 0 {
        return -n
    }
    return n
}

// ~int includes all types based on int
type MyInt int
Abs(MyInt(-5))  // Works!

// Generic struct with constraints
type Number interface {
    ~int | ~float64 | ~float32
}

type Stats[T Number] struct {
    values []T
}

func (s *Stats[T]) Add(v T) {
    s.values = append(s.values, v)
}

func (s *Stats[T]) Average() float64 {
    var sum float64
    for _, v := range s.values {
        sum += float64(v)
    }
    return sum / float64(len(s.values))
}

// Usage
s := &Stats[int]{}
s.Add(10)
s.Add(20)
fmt.Println(s.Average())  // 15

// Comparable for map keys
func Keys[K comparable, V any](m map[K]V) []K {
    keys := make([]K, 0, len(m))
    for k := range m {
        keys = append(keys, k)
    }
    return keys
}
```

**Key concepts:**
- `~T` — type and all types based on it.
- `|` — union (any of the types).
- `comparable` — can compare with == and !=.

Go: What are generics and type sets in Go?