Golang: Generics in Go

January 20, 2025

Introduction

Go 1.18 introduced one of the most significant features in the language's history: generics. After years of debate and careful design, Go developers can now write type-safe, reusable code without sacrificing the language's simplicity and performance characteristics.

What Are Generics?

Generics allow you to write functions and data structures that work with multiple types while maintaining type safety. Instead of writing separate functions for each type or using interface, you can write a single generic function that works with any type that satisfies certain constraints.

Before Generics (Go 1.17 and earlier):

before-generics.go

// Separate functions for different types
func MinInt(a, b int) int {
    if a < b {
        return a
    }
    return b
}

func MinFloat64(a, b float64) float64 {
    if a < b {
        return a
    }
    return b
}

// Or using interface{} (not type-safe)
func Min(a, b interface{}) interface{} {
    // Type assertions needed, runtime panics possible
    // Complex implementation required
}

With Generics (Go 1.18+):

with-generics.go

// Single generic function for all comparable types
func Min[T comparable](a, b T) T {
    if a < b {
        return a
    }
    return b
}

// Usage
result1 := Min(10, 20)        // Works with int
result2 := Min(3.14, 2.71)    // Works with float64
result3 := Min("hello", "world") // Works with string

Type Parameters and Constraints

Type parameters are defined in square brackets and can have constraints that specify what operations are allowed on the type.

Basic Type Parameters:

type-parameters.go

// T is a type parameter
func Identity[T any](value T) T {
    return value
}

// Multiple type parameters
func Pair[T, U any](first T, second U) (T, U) {
    return first, second
}

// Usage
id := Identity[int](42)
name := Identity[string]("Go")
pair := Pair[int, string](1, "one")

Type Constraints:

type-constraints.go

// Using built-in constraints
import "golang.org/x/exp/constraints"

func Add[T constraints.Ordered](a, b T) T {
    return a + b
}

// Custom constraint
type Numeric interface {
    int | int8 | int16 | int32 | int64 |
    uint | uint8 | uint16 | uint32 | uint64 |
    float32 | float64
}

func Multiply[T Numeric](a, b T) T {
    return a * b
}

Generic Data Structures

Generics shine when creating reusable data structures like stacks, queues, and maps.

Generic Stack Implementation:

stack.go

type Stack[T any] struct {
    items []T
}

func NewStack[T any]() *Stack[T] {
    return &Stack[T]{
        items: make([]T, 0),
    }
}

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
    }
    
    index := len(s.items) - 1
    item := s.items[index]
    s.items = s.items[:index]
    return item, true
}

func (s *Stack[T]) IsEmpty() bool {
    return len(s.items) == 0
}

// Usage
intStack := NewStack[int]()
intStack.Push(1)
intStack.Push(2)

stringStack := NewStack[string]()
stringStack.Push("hello")
stringStack.Push("world")

Real-World Example: Generic Cache

Here's a practical example of a generic in-memory cache that can store any type of value.

cache.go

package main

import (
    "fmt"
    "sync"
    "time"
)

type CacheItem[T any] struct {
    Value     T
    ExpiresAt time.Time
}

type Cache[K comparable, V any] struct {
    mu    sync.RWMutex
    items map[K]CacheItem[V]
}

func NewCache[K comparable, V any]() *Cache[K, V] {
    return &Cache[K, V]{
        items: make(map[K]CacheItem[V]),
    }
}

func (c *Cache[K, V]) Set(key K, value V, ttl time.Duration) {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    c.items[key] = CacheItem[V]{
        Value:     value,
        ExpiresAt: time.Now().Add(ttl),
    }
}

func (c *Cache[K, V]) Get(key K) (V, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    
    item, exists := c.items[key]
    if !exists || time.Now().After(item.ExpiresAt) {
        var zero V
        return zero, false
    }
    
    return item.Value, true
}

func main() {
    // String cache
    userCache := NewCache[int, string]()
    userCache.Set(1, "Alice", 5*time.Minute)
    
    if name, found := userCache.Get(1); found {
        fmt.Printf("User: %s
", name)
    }
    
    // Struct cache
    type User struct {
        Name  string
        Email string
    }
    
    structCache := NewCache[string, User]()
    structCache.Set("user1", User{"Bob", "bob@example.com"}, 10*time.Minute)
    
    if user, found := structCache.Get("user1"); found {
        fmt.Printf("User: %+v
", user)
    }
}

Best Practices

✅ Do:

Use generics when you need type safety with multiple types
Prefer specific constraints over 'any' when possible
Use meaningful type parameter names (T, K, V are fine for simple cases)
Consider using generics for data structures and algorithms

❌ Don't:

Use generics just because you can - they add complexity
Over-constrain your type parameters unnecessarily
Use generics for simple cases where interface would suffice
Create overly complex generic hierarchies

Conclusion

Generics in Go provide a powerful way to write reusable, type-safe code while maintaining the language's core principles of simplicity and performance. They're particularly useful for data structures, algorithms, and utility functions that need to work with multiple types. While they add some complexity, when used judiciously, they can significantly improve code quality and reduce duplication.

As you start using generics in your Go projects, remember to balance the benefits of type safety and code reuse with the added complexity they introduce. Start simple, and gradually explore more advanced patterns as you become comfortable with the syntax and concepts.