> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Go Type Constraint
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.
```go theme={"dark"}
// 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.
```go theme={"dark"}
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.
```go theme={"dark"}
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**.
```go theme={"dark"}
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.
```go theme={"dark"}
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.
```go theme={"dark"}
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
