Go generics allow developers to write functions, data structures, and reusable components that can work with multiple data types while maintaining type safety.

Before generics were introduced, Go developers often had to write separate functions for different types or use interface{} and perform type assertions. Generics provide a cleaner and safer solution.

Generics were officially introduced in Go 1.18 and have become an important part of modern Go programming.

In this guide, you’ll learn what generics are in Go, why they are useful, how type parameters and constraints work, and how to create generic functions and data structures with practical examples.

---

What Are Generics in Go?

Generics allow you to write code that works with different data types without rewriting the same logic for every type.

For example, suppose you want to create a function that returns the first element of a slice.

Without generics, you might create separate functions:

func FirstInt(items []int) int {
    return items[0]
}

func FirstString(items []string) string {
    return items[0]
}

Both functions perform exactly the same operation. The only difference is the data type.

With generics, you can write a single function:

func First[T any](items []T) T {
    return items[0]
}

Now the same function can work with different types:

fmt.Println(First([]int{10, 20, 30}))
fmt.Println(First([]string{"Go", "Java", "Rust"}))

Output:

10
Go

This is the main purpose of generics: write reusable code while preserving compile-time type safety.

---

Why Were Generics Added to Go?

Before Go 1.18, developers generally had three choices when implementing reusable logic.

1. Write Separate Functions

You could create separate functions for each type.

func PrintInts(values []int) {
    for _, value := range values {
        fmt.Println(value)
    }
}

func PrintStrings(values []string) {
    for _, value := range values {
        fmt.Println(value)
    }
}

This works, but creates duplicate code.

2. Use interface{}

Another approach was using the empty interface:

func PrintValue(value interface{}) {
    fmt.Println(value)
}

Because almost any value can be stored in interface{}, this approach is flexible.

However, when you need to perform type-specific operations, you often need type assertions or type switches.

3. Use Generics

Generics provide reusable code while allowing the compiler to understand the permitted types.

func PrintValue[T any](value T) {
    fmt.Println(value)
}

The compiler can check the types when the generic code is used.

---

Basic Syntax of Go Generics

A generic function usually looks like this:

func FunctionName[T Constraint](value T) T {
    return value
}

The important parts are:

T

A type parameter representing a type.

Constraint

Defines which types can be used for that parameter.

For example:

func Identity[T any](value T) T {
    return value
}

Here:

• T is the type parameter.
• any is the constraint.
• value T means the argument must have type T.
• The function returns a value of type T.

Usage:

fmt.Println(Identity(100))
fmt.Println(Identity("Hello"))
fmt.Println(Identity(true))

Output:

100
Hello
true

---

Understanding Type Parameters

Type parameters are placeholders for actual types.

Consider:

func Show[T any](value T) {
    fmt.Println(value)
}

When you call:

Show(100)

Go infers that T is int.

When you call:

Show("Hello")

Go infers that T is string.

Therefore, one generic function can work with multiple types.

You can also explicitly specify the type:

Show[int](100)
Show[string]("Hello")

However, explicit type arguments are often unnecessary because Go can infer them from function arguments.

---

What Does any Mean in Go?

The any identifier is an alias for interface{}.

These are equivalent:

interface{}

and:

any

In generic code, any is commonly used when the type parameter can be any type.

Example:

func Print[T any](value T) {
    fmt.Println(value)
}

You can use:

Print(100)
Print("Go")
Print(true)
Print(12.5)

---

Generic Function Example

Let’s create a function that returns the last element of a slice.

func Last[T any](items []T) T {
    return items[len(items)-1]
}

Usage:

package main

import "fmt"

func Last[T any](items []T) T {
    return items[len(items)-1]
}

func main() {
    numbers := []int{10, 20, 30, 40}
    languages := []string{"Go", "Rust", "Python"}

    fmt.Println(Last(numbers))
    fmt.Println(Last(languages))
}

Output:

40
Python

The same function works with both []int and []string.

---

Multiple Type Parameters

A generic function can contain more than one type parameter.

Example:

func Pair[T any, U any](first T, second U) {
    fmt.Println(first, second)
}

Usage:

Pair(10, "Go")
Pair("Age", 25)
Pair(true, 100.5)

Here:

• T represents the first value’s type.
• U represents the second value’s type.

The two types do not need to be the same.

---

What Are Constraints in Go Generics?

Constraints determine which types a type parameter is allowed to represent.

For example:

func Print[T any](value T)

The any constraint allows all types.

Sometimes, however, you need to restrict the function to specific types.

Suppose you want to add two values.

This won’t work:

func Add[T any](a, b T) T {
    return a + b
}

Why?

Because any includes types that don’t support the + operator.

For example, structs cannot generally be added together.

Therefore, we need a constraint.

---

Creating a Custom Type Constraint

You can create a constraint using an interface.

type Number interface {
    int | int32 | int64 | float32 | float64
}

Now create a generic function:

func Add[T Number](a, b T) T {
    return a + b
}

Complete example:

package main

import "fmt"

type Number interface {
    int | int32 | int64 | float32 | float64
}

func Add[T Number](a, b T) T {
    return a + b
}

func main() {
    fmt.Println(Add(10, 20))
    fmt.Println(Add(10.5, 20.5))
}

Output:

30
31

Now the compiler knows that T can only be one of the types listed in the constraint.

---

Understanding the | Operator in Constraints

Inside a type constraint, | represents a union of allowed type terms.

Example:

type Integer interface {
    int | int8 | int16 | int32 | int64
}

This means T can match one of those listed types.

You could use it like this:

func Double[T Integer](value T) T {
    return value * 2
}

Example:

fmt.Println(Double(10))

Output:

20

---

Understanding ~ in Go Constraints

Go also supports the ~ symbol in type constraints.

Consider this custom type:

type Age int

Now imagine this constraint:

type Integer interface {
    int
}

It specifically contains int, but a defined type such as Age is a distinct type even though its underlying type is int.

Using ~ changes the constraint:

type Integer interface {
    ~int
}

This means the constraint includes types whose underlying type is int.

Example:

package main

import "fmt"

type Integer interface {
    ~int
}

type Age int

func Double[T Integer](value T) T {
    return value * 2
}

func main() {
    var age Age = 20

    fmt.Println(Double(age))
}

Output:

40

This makes constraints more useful when working with user-defined types.

---

The comparable Constraint

Go provides a built-in constraint called:

comparable

It represents types that support equality comparison with:

==
!=

For example:

func Equal[T comparable](a, b T) bool {
    return a == b
}

Usage:

fmt.Println(Equal(10, 10))
fmt.Println(Equal("Go", "Rust"))

Output:

true
false

comparable is especially useful when implementing generic lookup logic or generic map-based structures.

---

Generic Slice Search Example

Let’s create a generic function that searches a slice.

func Contains[T comparable](items []T, target T) bool {
    for _, item := range items {
        if item == target {
            return true
        }
    }

    return false
}

Usage:

package main

import "fmt"

func Contains[T comparable](items []T, target T) bool {
    for _, item := range items {
        if item == target {
            return true
        }
    }

    return false
}

func main() {
    numbers := []int{10, 20, 30}
    languages := []string{"Go", "Rust", "Java"}

    fmt.Println(Contains(numbers, 20))
    fmt.Println(Contains(languages, "Python"))
}

Output:

true
false

The same function works with many comparable types.

---

Generic Map Example

Generics can also be useful when working with maps.

For example, we can create a function that returns all values from a map:

func Values[K comparable, V any](m map[K]V) []V {
    values := make([]V, 0, len(m))

    for _, value := range m {
        values = append(values, value)
    }

    return values
}

Here:

• K represents the map key.
• K must satisfy comparable because Go map keys must be comparable.
• V represents the map value.
• V can be any type.

Example:

func main() {
    users := map[int]string{
        1: "John",
        2: "Alice",
        3: "David",
    }

    fmt.Println(Values(users))
}

The order of map values is not guaranteed, so the output order may vary.

---

Generic Structs in Go

Generics aren’t limited to functions.

You can also create generic structs.

Consider a simple container:

type Box[T any] struct {
    Value T
}

Now you can create boxes containing different types.

intBox := Box[int]{
    Value: 100,
}

stringBox := Box[string]{
    Value: "Hello Go",
}

Complete example:

package main

import "fmt"

type Box[T any] struct {
    Value T
}

func main() {
    number := Box[int]{Value: 100}
    text := Box[string]{Value: "Hello Go"}

    fmt.Println(number.Value)
    fmt.Println(text.Value)
}

Output:

100
Hello Go

---

Generic Struct with Multiple Types

A struct can have multiple type parameters.

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

Example:

value := Pair[string, int]{
    First:  "Age",
    Second: 25,
}

Access the values:

fmt.Println(value.First)
fmt.Println(value.Second)

Output:

Age
25

This pattern can be useful when a reusable structure needs to store values of different types.

---

Generic Methods

Methods can use the type parameters declared by their receiver type.

Example:

type Box[T any] struct {
    Value T
}

func (b Box[T]) Get() T {
    return b.Value
}

Usage:

func main() {
    box := Box[string]{
        Value: "Go Generics",
    }

    fmt.Println(box.Get())
}

Output:

Go Generics

The method works with whatever type is used when the Box is instantiated.

---

Generic Stack Example

A stack is a good practical example of generics.

A stack follows the Last In, First Out (LIFO) principle.

Create the generic structure:

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

Add a Push method:

func (s *Stack[T]) Push(value T) {
    s.items = append(s.items, value)
}

Add a Pop method:

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }

    index := len(s.items) - 1
    value := s.items[index]

    s.items = s.items[:index]

    return value, true
}

Complete example:

package main

import "fmt"

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

func (s *Stack[T]) Push(value T) {
    s.items = append(s.items, value)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }

    index := len(s.items) - 1
    value := s.items[index]

    s.items = s.items[:index]

    return value, true
}

func main() {
    var stack Stack[int]

    stack.Push(10)
    stack.Push(20)
    stack.Push(30)

    value, ok := stack.Pop()

    if ok {
        fmt.Println(value)
    }
}

Output:

30

You can create another stack using strings:

var languages Stack[string]

languages.Push("Go")
languages.Push("Rust")
languages.Push("Java")

No duplicate stack implementation is required.

---

Zero Values in Generic Code

Sometimes generic functions need to return a zero value.

Since you don’t necessarily know what T will be, you cannot always write:

return 0

because T might be a string, struct, pointer, or another type.

Instead, declare a variable of type T:

var zero T

It automatically receives the zero value for that type.

Example:

func GetFirst[T any](items []T) (T, bool) {
    if len(items) == 0 {
        var zero T
        return zero, false
    }

    return items[0], true
}

For int, the zero value is:

0

For string:

""

For bool:

false

This is a common pattern in generic Go code.

---

Practical Example: Generic Minimum Function

Suppose we want to find the smaller of two numbers.

First define a constraint:

type Number interface {
    ~int | ~int32 | ~int64 | ~float32 | ~float64
}

Then:

func Min[T Number](a, b T) T {
    if a < b {
        return a
    }

    return b
}

Usage:

fmt.Println(Min(10, 20))
fmt.Println(Min(5.5, 2.3))

Output:

10
2.3

Because the constraint only contains types that support ordering, the < operation is valid.

---

Practical Example: Generic Maximum Function

The same concept can be used for a maximum function:

func Max[T Number](a, b T) T {
    if a > b {
        return a
    }

    return b
}

Example:

fmt.Println(Max(10, 50))
fmt.Println(Max(8.4, 3.2))

Output:

50
8.4

---

Practical Example: Generic Filter Function

Generics are useful for reusable slice operations.

Consider a filter function:

func Filter[T any](items []T, keep func(T) bool) []T {
    result := make([]T, 0)

    for _, item := range items {
        if keep(item) {
            result = append(result, item)
        }
    }

    return result
}

Usage:

numbers := []int{1, 2, 3, 4, 5, 6}

evenNumbers := Filter(numbers, func(value int) bool {
    return value%2 == 0
})

fmt.Println(evenNumbers)

Output:

[2 4 6]

The same generic function can filter strings:

words := []string{"Go", "Java", "Rust", "Python"}

shortWords := Filter(words, func(value string) bool {
    return len(value) <= 4
})

fmt.Println(shortWords)

Output:

[Go Java Rust]

---

Practical Example: Generic Map Transformation

You can create a function that transforms each element of a slice into another type.

func Map[T any, R any](items []T, transform func(T) R) []R {
    result := make([]R, len(items))

    for i, item := range items {
        result[i] = transform(item)
    }

    return result
}

Usage:

numbers := []int{1, 2, 3, 4}

strings := Map(numbers, func(value int) string {
    return fmt.Sprintf("Number: %d", value)
})

fmt.Println(strings)

Here:

• T represents the input type.
• R represents the result type.

The function can therefore transform one type into another.

---

Generics vs interface{}

Generics and interfaces solve different problems, although they sometimes appear in similar situations.

Consider:

func Print(value interface{}) {
    fmt.Println(value)
}

This accepts values of different types, but the function receives them through an interface.

With generics:

func Print[T any](value T) {
    fmt.Println(value)
}

The function is parameterized by the concrete type used for T.

Generics are particularly valuable when the relationship between input and output types matters.

For example:

func First[T any](items []T) T

If you provide:

[]string

the function returns:

string

If you provide:

[]int

it returns:

int

That type relationship is one of the biggest benefits of generics.

---

Benefits of Generics in Go

1. Less Duplicate Code

Instead of creating:

MinInt()
MinFloat()
MinInt64()

you can create one generic function:

Min[T Number]()

---

2. Compile-Time Type Safety

Generics allow the compiler to validate whether supplied types satisfy the required constraints.

This can prevent many type-related mistakes before the program runs.

---

3. Reusable Data Structures

Generics make structures such as:

• stacks
• queues
• containers
• sets
• trees
• caches

easier to implement without duplicating code for every stored type.

---

4. Cleaner APIs

Instead of returning a broad type and requiring callers to recover the expected type, generic APIs can preserve concrete type information.

For example:

func First[T any](items []T) T

clearly communicates the relationship between the slice element type and the return type.

---

When Should You Use Generics?

Generics are useful when the same logic genuinely applies to multiple types.

Good examples include:

Generic slice utilities
Reusable containers
Stacks and queues
Sets
Search functions
Min/max helpers
Filtering functions
Transformation functions
Reusable libraries

For example:

func Contains[T comparable](items []T, target T) bool

is a natural use of generics because the algorithm is identical for many comparable types.

---

When Should You Avoid Generics?

Not every function needs to be generic.

If your function only works with one specific type, using generics may add unnecessary complexity.

Instead of:

func Save[T User](user T) {
    // ...
}

a normal function may be clearer:

func Save(user User) {
    // ...
}

Use generics when they improve reuse and type safety—not simply because the language supports them.

---

Common Mistakes with Go Generics

Using any When Operations Require Constraints

Incorrect:

func Add[T any](a, b T) T {
    return a + b
}

The compiler cannot guarantee that every possible T supports +.

Use an appropriate constraint instead:

type Number interface {
    ~int | ~int64 | ~float32 | ~float64
}

func Add[T Number](a, b T) T {
    return a + b
}

---

Creating Too Many Type Parameters

Avoid introducing separate type parameters when they don’t provide meaningful flexibility.

For example, if two arguments must always have the same type:

func Equal[T comparable](a, b T) bool {
    return a == b
}

is clearer than creating unnecessary additional parameters.

---

Using Generics for Everything

Generic code can become harder to read when the problem isn’t actually generic.

Prefer simple Go code when only one concrete type is needed.

---

Complete Go Generics Example

Here’s a small program combining several concepts:

package main

import "fmt"

type Number interface {
    ~int | ~int64 | ~float32 | ~float64
}

func Add[T Number](a, b T) T {
    return a + b
}

func Contains[T comparable](items []T, target T) bool {
    for _, item := range items {
        if item == target {
            return true
        }
    }

    return false
}

type Box[T any] struct {
    Value T
}

func (b Box[T]) Get() T {
    return b.Value
}

func main() {
    // Generic numeric function
    fmt.Println(Add(10, 20))
    fmt.Println(Add(5.5, 2.5))

    // Generic slice function
    languages := []string{"Go", "Rust", "Python"}
    fmt.Println(Contains(languages, "Go"))

    // Generic struct
    box := Box[string]{
        Value: "Learning Go Generics",
    }

    fmt.Println(box.Get())
}

Possible output:

30
8
true
Learning Go Generics

---

Frequently Asked Questions

What are generics in Go?

Generics are a Go language feature that allows functions and types to work with multiple types through type parameters while preserving compile-time type checking.

When were generics introduced in Go?

Generics were officially introduced in Go 1.18.

What is a type parameter in Go?

A type parameter is a placeholder representing a type.

Example:

func Print[T any](value T)

Here, T is a type parameter.

What is a type constraint?

A constraint defines which types are permitted for a type parameter.

Example:

type Number interface {
    ~int | ~float64
}

What does any mean in Go generics?

any is an alias for interface{}. It allows a type parameter to represent any type.

What does comparable mean in Go?

comparable is a built-in constraint for types whose values can be compared using == and !=.

Example:

func Equal[T comparable](a, b T) bool {
    return a == b
}

What does ~ mean in Go constraints?

The ~ symbol allows a constraint to include types whose underlying type matches the specified type.

For example:

~int

can include int as well as defined types whose underlying type is int.

Can Go structs use generics?

Yes.

Example:

type Box[T any] struct {
    Value T
}

You can then create:

Box[int]{Value: 100}
Box[string]{Value: "Go"}

Can Go functions have multiple type parameters?

Yes.

func Pair[T any, U any](a T, b U) {
    fmt.Println(a, b)
}

Should beginners learn Go generics?

Yes, but after understanding basic Go concepts such as functions, slices, maps, structs, methods, and interfaces. Generics are much easier to understand once those fundamentals are familiar.

---

Conclusion

Go generics provide a powerful way to create reusable and type-safe code without writing separate implementations for every data type.

The most important concepts to understand are:

• Type parameters such as T
• Constraints that define permitted types
• any for unrestricted type parameters
• comparable for equality-comparable types
• Type unions using |
• Underlying-type constraints using ~
• Generic functions
• Generic structs and methods

A simple generic function might look like:

func First[T any](items []T) T {
    return items[0]
}

while a constrained generic function might look like:

func Add[T Number](a, b T) T {
    return a + b
}

The key principle is simple: use generics when the same algorithm or data structure should work safely with multiple types.

Once you understand type parameters and constraints, Go generics become a practical tool for reducing duplication and building cleaner reusable code.