Genéricos en Golang: parámetros de tipo, restricciones y ejemplos

Una función genérica

Los parámetros de tipo van entre corchetes antes de los parámetros normales. Cada uno tiene una restricción que dice qué tipos se permiten.

package main

import (
	"fmt"
	"strconv"
)

func Map[T, U any](items []T, f func(T) U) []U {
	out := make([]U, 0, len(items))
	for _, it := range items {
		out = append(out, f(it))
	}
	return out
}

func main() {
	nums := []int{1, 2, 3}

	squares := Map(nums, func(n int) int { return n * n })
	fmt.Println(squares)

	labels := Map(nums, strconv.Itoa)
	fmt.Printf("%q\n", labels)

	lengths := Map([]string{"go", "rust", "c"}, func(s string) int { return len(s) })
	fmt.Println(lengths)
}

T y U se infieren de los argumentos, así que rara vez escribes Map[int, string](...). La inferencia funciona a partir de los argumentos de la función; no puede inferir un tipo que solo aparece en el resultado. Para func Zero[T any]() T, tienes que escribir Zero[int]().

Antes de Go 1.18 esta función había que escribirla una vez por tipo, o recibir []interface{} y perder la seguridad de tipos.

Restricciones

Una restricción es una interfaz. Limita qué tipos se pueden usar y, a cambio, le dice al compilador qué operaciones se permiten sobre los valores de ese tipo.

package main

import (
	"cmp"
	"fmt"
)

func Index[T comparable](s []T, target T) int {
	for i, v := range s {
		if v == target { // needs comparable
			return i
		}
	}
	return -1
}

func Largest[T cmp.Ordered](s []T) T {
	m := s[0]
	for _, v := range s[1:] {
		if v > m { // needs cmp.Ordered
			m = v
		}
	}
	return m
}

func main() {
	fmt.Println(Index([]string{"a", "b", "c"}, "c"))
	fmt.Println(Largest([]float64{2.5, 9.1, 4.0}))
	fmt.Println(Largest([]string{"pear", "apple", "zucchini"}))
}

Con any en lugar de comparable, v == target no compila: invalid operation: v == target (incomparable types in type set). La restricción es lo que hace legal el operador.

Estas dos funciones auxiliares ya existen: slices.Index y slices.Max. Los paquetes estándar slices, maps y cmp cubren la mayoría de las necesidades genéricas del día a día, así que revísalos antes de escribir las tuyas.

Restricciones propias con uniones de tipos y ~

Una restricción puede enumerar tipos con |. Los operadores permitidos son los que admiten todos los tipos enumerados.

package main

import "fmt"

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

func Sum[T Number](nums []T) T {
	var total T
	for _, n := range nums {
		total += n
	}
	return total
}

type Cents int64

func main() {
	fmt.Println(Sum([]int{1, 2, 3}))
	fmt.Println(Sum([]float64{0.5, 0.25}))
	fmt.Println(Sum([]Cents{199, 250})) // works because of ~int64
}

La tilde importa. ~int64 significa "cualquier tipo cuyo tipo subyacente sea int64", así que se acepta el tipo con nombre Cents. Escrito como int64 a secas, Sum([]Cents{...}) falla con Cents does not satisfy Number (possibly missing ~ for int64 in Number).

Las interfaces que contienen uniones de tipos solo se pueden usar como restricciones, nunca como tipos normales de variable. var n Number no compila.

El paquete golang.org/x/exp/constraints tiene restricciones ya hechas como Integer, Float y Signed. Está fuera de la librería estándar, así que el entorno de ejecución de aquí no puede importarlo; cmp.Ordered es la estándar.

Tipos genéricos

Los structs, slices, maps y otros tipos también pueden tener parámetros de tipo. Los métodos de un tipo genérico usan los parámetros del receptor.

package main

import (
	"errors"
	"fmt"
)

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

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

func (s *Stack[T]) Pop() (T, error) {
	var zero T
	if len(s.items) == 0 {
		return zero, errors.New("empty stack")
	}
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, nil
}

func (s *Stack[T]) Len() int { return len(s.items) }

type Pair[K comparable, V any] struct {
	Key K
	Val V
}

func main() {
	var s Stack[string]
	s.Push("a")
	s.Push("b")
	v, _ := s.Pop()
	fmt.Println(v, s.Len())

	_, err := (&Stack[int]{}).Pop()
	fmt.Println(err)

	p := Pair[string, int]{Key: "age", Val: 31}
	fmt.Printf("%+v\n", p)
}

Dos detalles de este ejemplo aparecen constantemente:

• El valor cero de T. var zero T es la forma de devolver "nada" desde código genérico. No hay un T{} ni un nil que funcione para todos los tipos.
• Instanciación. Un tipo genérico tiene que instanciarse antes de usarlo: Stack[string], no Stack. Dentro de sus propios métodos, el receptor se escribe Stack[T].

Go 1.24 añadió los alias de tipo genéricos: type Set[T comparable] = map[T]struct{} ahora compila.

Límites con los que te vas a encontrar

• Los métodos no tienen parámetros de tipo propios. func (s *Stack[T]) Map[U any](...) no está permitido. Usa una función de nivel superior.
• Sin especialización. No puedes escribir una implementación aparte para T = string. Un type switch sobre any(v) dentro de la función es el apaño, y normalmente una señal de que los genéricos no son la herramienta adecuada.
• Sin restricciones de operadores por nombre. No puedes decir "cualquier tipo con un método +"; enumeras los tipos en una unión.
• El acceso a campos a través de una restricción no funciona. Aunque todos los tipos de una unión tengan un campo ID, v.ID no está permitido. Pon un método en la restricción.

Cuándo no usar genéricos

Los genéricos encajan en tipos contenedor (pilas, conjuntos, cachés, árboles) y en algoritmos sobre slices y maps que hacen lo mismo para cualquier tipo de elemento. No encajan en todas partes.

• Un solo tipo concreto. Si la función solo se llama con []User, una versión genérica añade coste de lectura y nada más.
• Comportamiento que cambia según el tipo. Para eso están las interfaces. Una función que recibe un io.Writer es más sencilla que una que recibe [T io.Writer], y funciona igual.
• Sustituir parámetros de interfaz. func Print[T fmt.Stringer](v T) no es mejor que func Print(v fmt.Stringer).

La pauta del propio equipo de Go: escribe primero el código para un tipo concreto, y recurre a los parámetros de tipo cuando te veas escribiendo el mismo código por segunda vez cambiando solo los tipos.

Errores comunes

• Usar any donde hace falta comparable o cmp.Ordered. El compilador rechaza == o < sobre un parámetro de tipo any.
• Olvidar ~. Los tipos definidos por el usuario como type ID int no cumplen una restricción int a secas.
• Devolver nil para un parámetro de tipo. No está permitido salvo que la restricción limite T a tipos de tipo puntero. Devuelve un valor cero.
• Escribir una función auxiliar genérica que ya existe. Revisa antes slices, maps y cmp.