Generics & Reflection

Advanced ~50 min read

Go 1.18 introduced generics, enabling type-safe code reuse without sacrificing performance. Combined with reflection for runtime type inspection, these features provide powerful tools for building flexible, maintainable applications. Master both to write modern, idiomatic Go code.

Generics in Go - Type Parameters and Constraints

Figure: Go Generics - Type Parameters, Generic Functions, Types, and Constraints

Introduction to Generics

Generics allow you to write functions and types that work with any type while maintaining type safety. The syntax uses square brackets [T any] for type parameters:

Output

Click Run to execute your code

Type Parameter Syntax:

[T any] - T is the type parameter, any is the constraint
any - Built-in constraint meaning "any type" (alias for interface{})
Type inference - Go can often infer T from arguments

Generic Functions

Generic functions can work with multiple types and transform data type-safely:

package main

import "fmt"

// Generic function that works with any slice
func Map[T, U any](slice []T, fn func(T) U) []U {
	result := make([]U, len(slice))
	for i, v := range slice {
		result[i] = fn(v)
	}
	return result
}

// Generic function with multiple type parameters
func Zip[T, U any](a []T, b []U) []struct {
	First  T
	Second U
} {
	length := len(a)
	if len(b) < length {
		length = len(b)
	}

result := make([]struct {
		First  T
		Second U
	}, length)
	for i := 0; i < length; i++ {
		result[i] = struct {
			First  T
			Second U
		}{a[i], b[i]}
	}
	return result
}

func main() {
	// Map: Transform []int to []string
	numbers := []int{1, 2, 3, 4, 5}
	strings := Map(numbers, func(n int) string {
		return fmt.Sprintf("Number: %d", n)
	})
	fmt.Println("Mapped:", strings)

// Map: Transform []string to []int (lengths)
	words := []string{"Go", "Generics", "Rock"}
	lengths := Map(words, func(s string) int {
		return len(s)
	})
	fmt.Println("Lengths:", lengths)

// Zip: Combine two slices
	names := []string{"Alice", "Bob", "Charlie"}
	ages := []int{25, 30, 35}
	combined := Zip(names, ages)

fmt.Println("\nZipped:")
	for _, pair := range combined {
		fmt.Printf("%s is %d years old\n", pair.First, pair.Second)
	}
}

Output

Click Run to execute your code

When to Use Generics:

Data structures (stacks, queues, trees)
Algorithms (sorting, searching, mapping)
Utility functions (Min, Max, Filter, Map)
When you'd otherwise use interface{} with type assertions

Generic Types

Create reusable data structures that work with any type:

package main

import "fmt"

// Generic Stack 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, 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
}

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

// Generic Pair type
type Pair[T, U any] struct {
	First  T
	Second U
}

func main() {
	// Stack of integers
	intStack := Stack[int]{}
	intStack.Push(1)
	intStack.Push(2)
	intStack.Push(3)

fmt.Println("Int Stack:")
	for !intStack.IsEmpty() {
		if val, ok := intStack.Pop(); ok {
			fmt.Println(val)
		}
	}

// Stack of strings
	strStack := Stack[string]{}
	strStack.Push("Go")
	strStack.Push("Generics")
	strStack.Push("Rock")

fmt.Println("\nString Stack:")
	for !strStack.IsEmpty() {
		if val, ok := strStack.Pop(); ok {
			fmt.Println(val)
		}
	}

// Generic Pair
	p1 := Pair[string, int]{"Alice", 25}
	p2 := Pair[int, bool]{42, true}

fmt.Printf("\nPairs:\n")
	fmt.Printf("p1: %v\n", p1)
	fmt.Printf("p2: %v\n", p2)
}

Output

Click Run to execute your code

Pro Tip: Generic types are instantiated with specific types like Stack[int] or Stack[string]. Each instantiation creates a separate type.

Type Constraints

Constraints limit which types can be used with generics:

package main

import (
	"fmt"

"golang.org/x/exp/constraints"
)

// Custom constraint using interface
type Number interface {
	int | int64 | float64
}

// Function using custom constraint
func Sum[T Number](numbers []T) T {
	var total T
	for _, n := range numbers {
		total += n
	}
	return total
}

// Using built-in constraints
func Min[T constraints.Ordered](a, b T) T {
	if a < b {
		return a
	}
	return b
}

// Constraint with methods
type Stringer interface {
	String() string
}

func PrintAll[T Stringer](items []T) {
	for _, item := range items {
		fmt.Println(item.String())
	}
}

// Custom type implementing Stringer
type Person struct {
	Name string
	Age  int
}

func (p Person) String() string {
	return fmt.Sprintf("%s (%d years)", p.Name, p.Age)
}

func main() {
	// Using Number constraint
	ints := []int{1, 2, 3, 4, 5}
	fmt.Println("Sum of ints:", Sum(ints))

floats := []float64{1.1, 2.2, 3.3}
	fmt.Println("Sum of floats:", Sum(floats))

// Using Ordered constraint
	fmt.Println("\nMin examples:")
	fmt.Println("Min(10, 20):", Min(10, 20))
	fmt.Println("Min(\"apple\", \"banana\"):", Min("apple", "banana"))

// Using interface constraint
	people := []Person{
		{"Alice", 25},
		{"Bob", 30},
		{"Charlie", 35},
	}

fmt.Println("\nPeople:")
	PrintAll(people)
}

Output

Click Run to execute your code

Constraint	Package	Description
`any`	Built-in	Any type (alias for interface{})
`comparable`	Built-in	Types that support == and !=
`constraints.Ordered`	golang.org/x/exp/constraints	Types that support <, >, <=, >=
Custom	Your code	Interface with type union

Reflection Basics

The reflect package provides runtime type inspection:

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name  string `json:"name" validate:"required"`
	Age   int    `json:"age" validate:"min=0,max=150"`
	Email string `json:"email"`
}

func main() {
	p := Person{Name: "Alice", Age: 25, Email: "alice@example.com"}

// Get type information
	t := reflect.TypeOf(p)
	fmt.Printf("Type: %v\n", t)
	fmt.Printf("Kind: %v\n", t.Kind())
	fmt.Printf("Name: %v\n\n", t.Name())

// Iterate over struct fields
	fmt.Println("Fields:")
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		fmt.Printf("  %s: %v", field.Name, field.Type)

// Get struct tags
		if jsonTag := field.Tag.Get("json"); jsonTag != "" {
			fmt.Printf(" [json:%s]", jsonTag)
		}
		if validateTag := field.Tag.Get("validate"); validateTag != "" {
			fmt.Printf(" [validate:%s]", validateTag)
		}
		fmt.Println()
	}

// Get value information
	v := reflect.ValueOf(p)
	fmt.Println("\nValues:")
	for i := 0; i < v.NumField(); i++ {
		field := v.Field(i)
		fieldName := t.Field(i).Name
		fmt.Printf("  %s = %v\n", fieldName, field.Interface())
	}

// Check if value is zero
	fmt.Println("\nZero value checks:")
	fmt.Printf("Name is zero: %v\n", reflect.ValueOf(p.Name).IsZero())
	fmt.Printf("Age is zero: %v\n", reflect.ValueOf(p.Age).IsZero())
}

Output

Click Run to execute your code

Reflection Concepts:

reflect.TypeOf() - Get type information
reflect.ValueOf() - Get value information
Type.Kind() - Get underlying kind (struct, int, etc.)
Type.Field() - Access struct fields
Field.Tag - Read struct tags

Advanced Reflection

Reflection enables dynamic method calls and field modification:

package main

import (
	"fmt"
	"reflect"
)

type Calculator struct {
	Value int
}

func (c *Calculator) Add(n int) int {
	c.Value += n
	return c.Value
}

func (c *Calculator) Multiply(n int) int {
	c.Value *= n
	return c.Value
}

func (c Calculator) GetValue() int {
	return c.Value
}

func callMethod(obj interface{}, methodName string, args ...interface{}) {
	// Get value
	v := reflect.ValueOf(obj)

// Get method
	method := v.MethodByName(methodName)
	if !method.IsValid() {
		fmt.Printf("Method %s not found\n", methodName)
		return
	}

// Prepare arguments
	in := make([]reflect.Value, len(args))
	for i, arg := range args {
		in[i] = reflect.ValueOf(arg)
	}

// Call method
	results := method.Call(in)

// Print results
	fmt.Printf("Called %s: ", methodName)
	for _, result := range results {
		fmt.Printf("%v ", result.Interface())
	}
	fmt.Println()
}

func inspectMethods(obj interface{}) {
	t := reflect.TypeOf(obj)
	fmt.Printf("\nMethods of %v:\n", t)

for i := 0; i < t.NumMethod(); i++ {
		method := t.Method(i)
		fmt.Printf("  %s: %v\n", method.Name, method.Type)
	}
}

func main() {
	calc := &Calculator{Value: 10}

fmt.Println("Initial value:", calc.Value)

// Call methods dynamically
	callMethod(calc, "Add", 5)
	callMethod(calc, "Multiply", 3)
	callMethod(calc, "GetValue")

// Inspect available methods
	inspectMethods(calc)

// Modify struct field using reflection
	v := reflect.ValueOf(calc).Elem()
	field := v.FieldByName("Value")
	if field.CanSet() {
		field.SetInt(100)
		fmt.Println("\nValue set to 100 via reflection")
		fmt.Println("New value:", calc.Value)
	}
}

Output

Click Run to execute your code

Reflection Performance: Reflection is slower than direct code. Use it when flexibility is more important than performance (serialization, ORMs, dependency injection).

Generics vs Reflection

Aspect	Generics	Reflection
Type Safety	✅ Compile-time	❌ Runtime only
Performance	✅ Fast (no overhead)	⚠️ Slower
Flexibility	⚠️ Limited to constraints	✅ Very flexible
Use Case	Data structures, algorithms	Serialization, ORMs, DI

Common Mistakes

1. Over-using generics

// ❌ Wrong - generics not needed
func AddInts[T int](a, b T) T {
    return a + b
}

// ✅ Correct - just use int
func AddInts(a, b int) int {
    return a + b
}

2. Forgetting to check CanSet() in reflection

// ❌ Wrong - will panic
v := reflect.ValueOf(myStruct)
v.FieldByName("Name").SetString("Alice")

// ✅ Correct - use pointer and check
v := reflect.ValueOf(&myStruct).Elem()
field := v.FieldByName("Name")
if field.CanSet() {
    field.SetString("Alice")
}

Exercise: Generic Cache with Reflection

Task: Build a generic cache that uses reflection to validate stored values.

Requirements:

Generic Cache[K comparable, V any] type
Get/Set methods
Use reflection to log type information
Validate that keys are comparable

Show Solution

package main

import (
    "fmt"
    "reflect"
    "sync"
)

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

func NewCache[K comparable, V any]() *Cache[K, V] {
    c := &Cache[K, V]{
        items: make(map[K]V),
    }
    
    // Log type information using reflection
    var k K
    var v V
    fmt.Printf("Created cache with key type: %v, value type: %v\n",
        reflect.TypeOf(k), reflect.TypeOf(v))
    
    return c
}

func (c *Cache[K, V]) Set(key K, value V) {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    // Use reflection to log value details
    vType := reflect.TypeOf(value)
    vValue := reflect.ValueOf(value)
    fmt.Printf("Setting key=%v, value type=%v, kind=%v\n",
        key, vType, vValue.Kind())
    
    c.items[key] = value
}

func (c *Cache[K, V]) Get(key K) (V, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    
    value, ok := c.items[key]
    return value, ok
}

func main() {
    // String -> int cache
    cache1 := NewCache[string, int]()
    cache1.Set("age", 25)
    cache1.Set("score", 100)
    
    if age, ok := cache1.Get("age"); ok {
        fmt.Printf("Age: %d\n", age)
    }
    
    // Int -> struct cache
    type Person struct {
        Name string
        Age  int
    }
    
    cache2 := NewCache[int, Person]()
    cache2.Set(1, Person{"Alice", 25})
    cache2.Set(2, Person{"Bob", 30})
    
    if person, ok := cache2.Get(1); ok {
        fmt.Printf("Person: %+v\n", person)
    }
}

Summary

Generics (Go 1.18+) enable type-safe code reuse
Type parameters use syntax [T any]
Constraints limit which types can be used
Type inference often eliminates need to specify types
Generic types create reusable data structures
Reflection provides runtime type inspection
reflect.TypeOf() gets type information
reflect.ValueOf() gets value information
Prefer generics over reflection for performance
Use reflection when you need runtime flexibility

Congratulations!

You've completed the advanced Go topics! You now have a comprehensive understanding of Go's modern features including generics and reflection. These tools, combined with everything you've learned, make you ready to build production-grade Go applications.

Previous Goroutine Coordination

Next Memory Management

Introduction to Generics

Generic Functions

Generic Types

Type Constraints

Reflection Basics

Advanced Reflection

Generics vs Reflection

Common Mistakes

1. Over-using generics

2. Forgetting to check CanSet() in reflection

Exercise: Generic Cache with Reflection

Summary

Congratulations!

Enjoying these tutorials?