Parámetros de Tipo y Interfaces de Restricción

Los parámetros de tipo se declaran en listas de corchetes, y las interfaces de restricción definen qué tipos pueden reemplazarlos usando métodos, tipos subyacentes (~T) y uniones (|).

Resumen

Los parámetros de tipo convierten tipos concretos en variables de tiempo de compilación para funciones y tipos nombrados.

Las interfaces de restricción son las barreras de seguridad: enumeran las operaciones y conjuntos de tipos permitidos.

El operador ~ coincide con tipos nombrados por su tipo subyacente; | une múltiples tipos o tipos subyacentes en una restricción.

Los tipos de restricción nombrados mantienen las API legibles cuando el mismo límite aparece en muchas firmas.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

// Restricción nombrada - reutilizable en APIs
type Ordered interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
    ~float32 | ~float64 |
    ~string
}
 
func Clamp[T Ordered](v, lo, hi T) T {
    if v < lo {
        return lo
    }
    if v > hi {
        return hi
    }
    return v
}

Cuándo usar esto:

• Necesitas un cuerpo de función para varios tipos concretos que comparten operadores o métodos.
• Un tipo nombrado debe participar porque su tipo subyacente coincide (~byte).
• Se deben aceptar múltiples tipos no relacionados a través de una unión (int | string es inválido para operaciones compartidas - diseña con cuidado).

Ejemplo de Trabajo

package main
 
import (
    "fmt"
    "strconv"
)
 
// Restricción de método
type Stringable interface {
    String() string
}
 
// Tipo subyacente + unión
type Digit interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}
 
type UserID int
 
func (id UserID) String() string {
    return strconv.Itoa(int(id))
}
 
func FormatAll[T Stringable](items []T) string {
    out := ""
    for i, v := range items {
        if i > 0 {
            out += ", "
        }
        out += v.String()
    }
    return out
}
 
func Twice[T Digit](v T) T {
    return v * 2
}
 
func main() {
    ids := []UserID{1, 2, 3}
    fmt.Println(FormatAll(ids))
    fmt.Println(Twice(UserID(5)))
}

Lo que esto demuestra:

• Las restricciones de método permiten llamadas como v.String() dentro del cuerpo genérico.
• ~int permite que UserID satisfaga Digit sin listar cada tipo int nombrado.
• Las restricciones separadas componen diferentes capacidades (Stringable vs Digit).

Análisis Profundo

Cómo Funciona

• Los parámetros de tipo se declaran en funciones (func F[T any]()) o tipos (type Stack[T any] struct{}).
• Cada parámetro tiene una interfaz de restricción; el uso no restringido por defecto es any.
• El compilador calcula el conjunto de tipos de la restricción; solo los tipos en ese conjunto pueden instanciar el genérico.
• El cuerpo de la función solo puede usar operaciones válidas para todos los tipos del conjunto (las reglas del conjunto de tipos principal).

Formas de Restricción de un Vistazo

Listas de Parámetros de Tipo

Notas de Go

// Extrae restricciones a nombres a nivel de paquete para APIs públicas
type JSONMarshaler interface {
    MarshalJSON() ([]byte, error)
}
 
func Encode[T JSONMarshaler](v T) ([]byte, error) {
    return v.MarshalJSON()
}
 
// Incrustando restricciones predefinidas
type Key interface {
    comparable
    fmt.Stringer
}

• Las interfaces de restricción no pueden incrustar tipos arbitrarios no-interfaz, excepto términos de tipo en uniones.
• Una unión no puede mezclar operaciones incompatibles: si a un brazo le falta <, el cuerpo no puede usar < en T.
• Usa cmp.Ordered y cmp.Or de la biblioteca estándar en lugar de copiar listas de unión grandes.

Trampas Comunes

• Usar int en lugar de ~int: Los tipos nombrados como type Celsius float64 no coincidirán solo con float64. Solución: usa ~float64 cuando los tipos nombrados deban calificar.
• Unión demasiado amplia para un cuerpo: int | string no puede usar + o comparaciones compartidas más allá de == si no son comparables juntas. Solución: reduce la unión o divide las funciones.
• Incrustar comparable incorrectamente: interface { comparable; []byte } es inválido porque los slices no son comparables. Solución: lista solo términos de tipo comparables.
• Interfaz de restricción solo con métodos, sin conjunto de tipos: Los conjuntos de métodos de interfaz vacía se comportan de manera diferente a las uniones; lee la especificación para los conjuntos de tipos principales de comparable. Solución: prueba las instanciaciones en tablas de pruebas de tiempo de compilación.
• Exportar uniones de restricción enormes: Las APIs públicas se vuelven difíciles de leer y estabilizar. Solución: des-exporta la restricción, exporta la función con límites mínimos.
• Parámetros de tipo duplicados: [T any, T comparable] es inválido. Solución: un nombre por parámetro en la lista.

Alternativas

Preguntas Frecuentes

Relacionados

• Generics in Go: Constraints Without Templates - vista general conceptual
• Generics Basics - primeros fragmentos genéricos
• Type Sets & the comparable Constraint - análisis profundo de comparable
• Generic Algorithms: slices, maps & cmp Packages - uso de cmp.Ordered
• When to Avoid Generics in Go APIs - guía de API pública

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado GC Green Tea, go fix modernizers - verifica el parche en la compilación), chi (última - verifica en la compilación), gin (última - verifica en la compilación), echo (última - verifica en la compilación), google.golang.org/grpc (última - verifica en la compilación), sigs.k8s.io/controller-runtime (última - verifica en la compilación), kubebuilder (última - verifica en la compilación), tinygo (última - verifica objetivos de placa en la compilación), wazero (última - verifica en la compilación) y golangci-lint (última - verifica el conjunto de linters en la compilación).

49454e4f4d5f434e4f5904434556494d43451f1a1d56181a181c1a1d