Skip to main content
A type constraint in Go is an interface that defines the permissible set of types that can be instantiated for a type parameter in a generic function or generic data structure. Introduced in Go 1.18, constraints expand the definition of interfaces from strictly representing a method set to representing a type set. If a type belongs to the type set defined by the constraint, it successfully satisfies that constraint.

​
Syntax Visualization

Constraints are applied within square brackets [...] immediately following a function or type name, declaring the type parameter and its corresponding constraint. 
// Define a custom constraint
type Numeric interface {
    ~int | ~float64
}

// T is the type parameter, Numeric is the type constraint
func Process[T Numeric](input T) T {
    return input
}

// Multiple type parameters with different constraints
type Dictionary[K comparable, V any] struct {
    data map[K]V
}

​
Interfaces as Type Sets

When an interface is used as a constraint, it dictates the exact types allowed. This is achieved using type elements. 
type SignedInteger interface {
    int | int8 | int16 | int32 | int64
}
In this context, SignedInteger is not checking for methods; it is defining a closed type set. Only the exact types listed can satisfy this constraint.

​
The Union Operator (|)

The pipe | acts as a union operator within an interface definition. It combines multiple types into a single constraint. A type argument satisfies the constraint if it matches any of the types in the union. 
type Float interface {
    float32 | float64
}

​
The Approximation Operator (~)

By default, a constraint requires a strict type match. If a constraint specifies int, a custom type defined as type MyInt int will fail the constraint check. The tilde ~ operator relaxes this by specifying the underlying type. 
type AnyString interface {
    ~string
}

type MyString string

// MyString satisfies AnyString because its underlying type is string.
Restriction: The ~ operator can only be applied to types whose underlying type is itself. This includes predeclared types (like int or string) and type literals (like []byte, map[string]int, or struct{ id int }). It cannot be applied to interfaces or type parameters.

​
Inline Constraints

Constraints do not need to be explicitly declared as named interfaces. They can be defined anonymously directly within the type parameter list. 
func Add[T ~int | ~float64](a, b T) T {
    return a + b
}

​
Predeclared Constraints

Go provides two built-in constraints that do not require explicit interface definitions:
  1. any: An alias for the empty interface interface{}. Its type set is infinite, meaning it imposes no restrictions. Any type satisfies any.
  2. comparable: A specialized, compiler-enforced constraint. Its type set consists of all types that support the equality operators == and !=. This includes booleans, numbers, strings, pointers, channels, and structs/arrays composed exclusively of comparable types. It explicitly excludes slices, maps, and functions.

​
Combining Methods and Type Elements

A constraint can enforce both a specific type set and a method set simultaneously. A type argument must belong to the union of types and also implement all declared methods. 
type StringableInteger interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
    String() string
}
Note: Interfaces that contain type elements (unions or approximations) can only be used as type constraints. They cannot be used as standard interface types for variable declarations.
Tired of Poor Go Skills? Fix That With Deep Grasping!Learn More