Skip to main content

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.

A generic function in Go is a function declared with one or more type parameters, enabling it to operate across a defined set of types while maintaining strict compile-time type safety. Type parameters act as placeholders that are resolved to specific concrete types (type arguments) at compile time through a process called instantiation.

​
Syntax Anatomy

Generic functions introduce a type parameter list enclosed in square brackets [...], positioned immediately after the function name and before the standard parameter list. 
func FunctionName[T Constraint](param T) ReturnType {
    // function body
}
  • T (Type Parameter): The identifier used within the function signature and body to represent the generic type.
  • Constraint (Type Constraint): An interface that dictates the permissible set of types (the “type set”) that can be substituted for T.

​
Type Constraints

Every type parameter must be bound by a constraint. Constraints are evaluated at compile time to ensure the operations performed on the type parameter within the function body are valid for all types in the constraint’s type set.
  1. any: An alias for the empty interface (interface{}). It imposes no restrictions, meaning the type set is infinite.
  2. comparable: A built-in constraint that restricts the type set to types that support the equality operators (== and !=).
  3. Union Constraints: Interfaces that define a specific set of permissible underlying types using the pipe | operator.
// A custom constraint defining a specific type set
type Numeric interface {
    int | int32 | int64 | float32 | float64
}

// A generic function utilizing the custom constraint
func Process[T Numeric](input T) T {
    return input * 2 // Valid because all types in 'Numeric' support multiplication
}

​
The Tilde (~) Operator

When defining union constraints, the tilde ~ operator specifies that the constraint applies to the underlying type, rather than just the exact named type. This allows custom types derived from primitives to satisfy the constraint. 
type FlexibleNumeric interface {
    ~int | ~float64
}

type CustomInt int

// CustomInt satisfies FlexibleNumeric because its underlying type is int

​
Instantiation and Type Inference

To execute a generic function, it must be instantiated. Instantiation is the two-step process of substituting type arguments for type parameters, followed by verifying that the type arguments implement their respective constraints. 1. Explicit Instantiation The developer explicitly provides the type arguments in square brackets during the function call. 
func Identity[T any](val T) T {
    return val
}

// Explicitly providing 'string' as the type argument
result := Identity[string]("Go")
2. Implicit Instantiation (Type Inference) The Go compiler deduces the type arguments based on the types of the standard arguments passed to the function. If the compiler can unambiguously infer the type, the explicit type argument list can be omitted. 
// The compiler infers 'T' is 'float64' based on the argument '3.14'
result := Identity(3.14)

​
Multiple Type Parameters

Generic functions can declare multiple type parameters, each with its own constraint. These parameters can be interdependent. 
func MapKeys[K comparable, V any](m map[K]V) []K {
    keys := make([]K, 0, len(m))
    for k := range m {
        keys = append(keys, k)
    }
    return keys
}
In this signature, K is constrained to comparable (a requirement for map keys in Go), while V is constrained to any (map values can be of any type).
Master Go with Deep Grasping Methodology!Learn More