Go generics for type-safe data structures

Before Go 1.18, generic data structures required interface{} or code generation, losing type safety.

Use Go generics for reusable, type-safe code:

// Generic stack
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, bool) {
if len(s.items) == 0 {
var zero T
return zero, false
}
item := s.items[len(s.items)-1]
s.items = s.items[:len(s.items)-1]
return item, true
}

// Generic Map/Filter/Reduce
func MapT, U any U) []U {
result := make([]U, len(slice))
for i, v := range slice {
result[i] = fn(v)
}
return result
}

func FilterT any bool) []T {
var result []T
for _, v := range slice {
if fn(v) {
result = append(result, v)
}
}
return result
}

// Type constraints
type Number interface {
~int | ~int64 | ~float64
}

func SumT Number T {
var total T
for _, n := range nums {
total += n
}
return total
}

// Usage:
s := Stack[string]{}
s.Push("hello")
nums := []int{1, 2, 3, 4, 5}
evens := Filter(nums, func(n int) bool { return n%2 == 0 })

Generics eliminate the need for interface{} casts or code generation while maintaining Go's type safety and performance.