Lección 18 de 36 · Interfaces, composición y genéricos✦ WebMCP implementado
Genéricos: lo que en PHP era @template
9 min de lectura3 retos
En PHP escribes @template T en un comentario y solo PHPStan o Psalm lo miran. En Go los genéricos son parte del lenguaje: una sola función Filtrar[T] sirve para tareas, números o textos, y el compilador comprueba cada uso.
¿De dónde vienen los nombres?
T = Type (tipo)
Costumbre heredada de los templates de C++ y Java: el parámetro de tipo se llama T. Si hay más, K (key, clave) y V (value, valor), o U. En PHPStan escribes también @template T.
cmp = compare (comparar)
El paquete con la restricción cmp.Ordered (tipos que se pueden ordenar con <) y la función cmp.Compare, la nave espacial <=> de PHP.
~ = tilde (virgulilla)
En una restricción, ~int significa «int o cualquier tipo cuyo tipo de base sea int», como tu Prioridad del módulo 04.
En 4 ideas
1/4
Una función genérica lleva sus parámetros de tipo entre corchetes, antes de los argumentos: func Filtrar[T any]. En PHP es el @template T de PHPStan, pero aquí lo comprueba el compilador.
Go deduceT al llamar: Filtrar(tareas, …) sabe que T es Tarea. Como PHPStan cuando infiere el tipo de un @template.
La restricción dice qué puede ser T: any (cualquiera), comparable (se puede usar ==), cmp.Ordered (se puede usar <) o una interfaz tuya. En PHP es @template T of Tarea.
También hay tipos genéricos: Conjunto[T comparable] o Pagina[T any]. Es tu Collection<int, Tarea> de Laravel, pero de verdad, no en un comentario.
1 · @template en un comentario frente a genéricos de verdad
Imagina un molde de galletas. El molde es siempre el mismo; la masa cambia: chocolate, vainilla, limón. Un genérico es un molde de código: escribes Filtrar una vez y sirve para filtrar tareas, IDs o etiquetas.
Sin genéricos tienes dos malas opciones: copiar la función para cada tipo (FiltrarTareas, FiltrarInts…) o usar any y perder el tipo por el camino (lo viste en la lección 1). En PHP pasa lo mismo con array y mixed, y por eso PHPStan y Psalm inventaron @template:
PHP 8.5filtrar.php
<?phpdeclare(strict_types=1);
finalreadonlyclass Tarea
{
publicfunction__construct(
public string $titulo,
public bool $hecha = false,
) {}
}
/** * @template T * @param list<T> $xs * @param callable(T): bool $f * @return list<T> */functionfiltrar(array$xs, callable $f): array
{
returnarray_values(array_filter($xs, $f));
}
$tareas = [newTarea("Comprar pan"), newTarea("Repasar Go", hecha: true)];
$pendientes = filtrar($tareas, fn(Tarea $t): bool => !$t->hecha);
// PHP no lee el @template: solo PHPStan o Psalm lo comprueban.echocount($pendientes) . PHP_EOL;
Gomain.go
package main
import"fmt"typeTareastruct {
TitulostringHechabool
}
// [T any]: T es un tipo cualquiera que se decide al llamar.// En PHP: /** @template T @param list<T> $xs @return list<T> */funcFiltrar[Tany](xs []T, f func(T) bool) []T {
var aceptados []Tfor _, x := range xs {
iff(x) {
aceptados = append(aceptados, x)
}
}
return aceptados
}
funcmain() {
tareas := []Tarea{{Titulo: "Comprar pan"}, {Titulo: "Repasar Go", Hecha: true}}
// En PHP: fn(Tarea $t): bool => !$t->hecha
pendientes := Filtrar(tareas, func(t Tarea) bool { return !t.Hecha })
// pendientes es []Tarea, no []any: el tipo no se pierde.
fmt.Println(len(pendientes), pendientes[0].Titulo)
}
func(t Tarea) bool { … } es una función anónima: tu fn(Tarea $t): bool => …. Las verás a fondo en el módulo 06.
¿Por qué? · En PHP no existe
¿Por qué genéricos en el lenguaje y no en un comentario? En PHP no existen
En PHP, @template es un comentario. Si llamas a filtrar() con lo que no toca, PHP lo ejecuta igual; solo te avisa PHPStan, si lo pasas. Y si no lo pasas en el CI, el error llega a producción.
En Go el compilador comprueba cada llamada. Si Filtrar devuelve []Tarea, intentar usar el resultado como []string no compila. Además:
No hay que convertir de any a mano (v.(Tarea)), así que no hay pánicos por un tipo equivocado.
El código es igual de rápido que si lo hubieras escrito para cada tipo: no hay comprobaciones al ejecutar.
Go tardó 13 años en añadirlos (llegaron en Go 1.18, en 2022) para hacerlos simples: no hay herencia de genéricos ni varianza como en @template-covariant.
2 · Funciones genéricas y deducción de tipos
Una función genérica puede tener varios parámetros de tipo. Mapear convierte cada T en un U: es tu array_map(). Normalmente Go deduce los tipos por los argumentos; si no puede, o quieres dejarlo claro, los escribes tú entre corchetes:
Gomain.go
package main
import"fmt"typeTareastruct {
TitulostringHechabool
}
funcFiltrar[Tany](xs []T, f func(T) bool) []T {
var aceptados []Tfor _, x := range xs {
iff(x) {
aceptados = append(aceptados, x)
}
}
return aceptados
}
// En PHP: array_map($f, $xs) con /** @template T @template U */funcMapear[T, Uany](xs []T, f func(T) U) []U {
resultado := make([]U, 0, len(xs))
for _, x := range xs {
resultado = append(resultado, f(x))
}
return resultado
}
funcmain() {
tareas := []Tarea{
{Titulo: "Comprar pan"},
{Titulo: "Repasar Go", Hecha: true},
{Titulo: "Regar"},
}
// Go deduce T = Tarea y U = string.
pendientes := Filtrar(tareas, func(t Tarea) bool { return !t.Hecha })
titulos := Mapear(pendientes, func(t Tarea) string { return t.Titulo })
fmt.Println(titulos)
// La misma función, ahora con int.
ids := []int{3, 8, 12, 15}
fmt.Println(Filtrar(ids, func(n int) bool { return n%2 == 0 }))
// Tipos escritos a mano: T = string, U = int.
largos := Mapear[string, int](titulos, func(s string) int { returnlen(s) })
fmt.Println(largos)
}
3 · Restricciones: any, comparable y cmp.Ordered
Con [T any] Go solo te deja hacer con T lo que vale para todos los tipos: guardarlo, pasarlo, devolverlo. Ni siquiera ==, porque hay tipos que no se pueden comparar (un slice, un map). Si lo intentas:
Gomain.go
funcContiene[Tany](xs []T, x T) bool {
for _, v := range xs {
if v == x {
returntrue
}
}
returnfalse
}
invalid operation: v == x (incomparable types in type set)
La restricción (lo que va detrás de T) es una interfaz que dice qué puede hacer T. Es como el cartel de una atracción: «solo mayores de 1,40 m». Las más usadas:
Restricción
Permite
En PHPStan
any
Guardar, pasar y devolver
@template T
comparable
Además == y !=; sirve de clave de un map
No hay equivalente
cmp.Ordered
Además <, >, <=, >= (números y strings)
No hay equivalente
Una interfaz tuya (Describible)
Llamar a sus métodos
@template T of Describible
~int | ~float64
Los operadores de los números (+, *…)
@template T of int|float
Gomain.go
package main
import (
"cmp""fmt"
)
typePrioridadintconst (
BajaPrioridad = iotaMediaAlta
)
// comparable: hace falta para usar ==funcContiene[Tcomparable](xs []T, x T) bool {
for _, v := range xs {
if v == x {
returntrue
}
}
returnfalse
}
// cmp.Ordered: hace falta para usar >. Con «comma ok» por si está vacío.funcMayor[T cmp.Ordered](xs []T) (T, bool) {
var mayor Tiflen(xs) == 0 {
return mayor, false
}
mayor = xs[0]
for _, x := range xs[1:] {
if x > mayor {
mayor = x
}
}
return mayor, true
}
// Restricción propia: int, float64 o cualquier tipo basado en ellos (~).typeNumerointerface {
~int | ~float64
}
funcSumar[TNumero](xs []T) T {
var total Tfor _, x := range xs {
total += x
}
return total
}
funcmain() {
fmt.Println(Contiene([]string{"casa", "trabajo"}, "casa"))
fmt.Println(Contiene([]int{1, 2, 3}, 7))
// Prioridad tiene int de base, así que cumple cmp.Ordered.
p, ok := Mayor([]Prioridad{Baja, Alta, Media})
fmt.Println(p == Alta, ok)
titulo, _ := Mayor([]string{"Regar", "Comprar pan"})
fmt.Println(titulo)
fmt.Println(Sumar([]Prioridad{Media, Alta}))
fmt.Println(Sumar([]float64{1.5, 2.25}))
}
Si pasas un tipo que no cumple la restricción, el error dice exactamente qué falta. Por ejemplo, ordenar structs Tarea con cmp.Ordered:
Un struct también puede tener parámetros de tipo. En Laravel anotas @var Collection<int, Tarea> en un comentario y confías. En Go el tipo esPagina[Tarea], y meter otra cosa no compila:
Gomain.go
package main
import"fmt"typeTareastruct {
IDintTitulostring
}
// Un conjunto: cada valor una sola vez. En PHP: $set[$valor] = true;// struct{} es un struct vacío: no ocupa memoria, solo nos importa la clave.typeConjunto[Tcomparable] struct {
items map[T]struct{}
}
funcNuevoConjunto[Tcomparable]() *Conjunto[T] {
return &Conjunto[T]{items: map[T]struct{}{}}
}
func (c *Conjunto[T]) Agregar(x T) {
c.items[x] = struct{}{}
}
func (c *Conjunto[T]) Tiene(x T) bool {
_, ok := c.items[x]
return ok
}
func (c *Conjunto[T]) Len() int {
returnlen(c.items)
}
// Una página de resultados de cualquier cosa (tareas, usuarios…).typePagina[Tany] struct {
Items []TNumerointTotalint
}
funcmain() {
etiquetas := NuevoConjunto[string]()
etiquetas.Agregar("casa")
etiquetas.Agregar("trabajo")
etiquetas.Agregar("casa")
fmt.Println(etiquetas.Len(), etiquetas.Tiene("casa"), etiquetas.Tiene("ocio"))
p := Pagina[Tarea]{
Items: []Tarea{{ID: 1, Titulo: "Comprar pan"}, {ID: 2, Titulo: "Regar"}},
Numero: 1,
Total: 5,
}
fmt.Printf("Página %d: %d de %d tareas\n", p.Numero, len(p.Items), p.Total)
}
Fíjate en que los métodos repiten el parámetro: func (c *Conjunto[T]) Agregar(x T). Y al crear un conjunto vacío, NuevoConjunto[string] lleva el tipo a mano, porque no hay ningún argumento del que deducirlo.
Equivalencia POO · PHP → Go
Lo que en PHP son anotaciones para PHPStan, en Go es sintaxis que el compilador entiende y comprueba.
PHP
Go
Quién lo comprueba
/** @template T */
func Filtrar[T any]
El compilador de Go; en PHP, solo PHPStan o Psalm
/** @template T of Describible */
[T Describible] (la interfaz como restricción)
El compilador, en cada llamada
/** @param list<T> $xs */
xs []T
El compilador: no hay comentarios que puedan mentir
/** @var Collection<int, Tarea> */
Pagina[Tarea], map[int]Tarea
El compilador: meter otra cosa no compila
final class TareaCollection (una clase por tipo)
Conjunto[T]: un tipo para todos
Se escribe una vez y se usa con cualquier T
mixed
any: acepta todo, pero pierde el tipo
Nadie: tienes que preguntar el tipo tú
5 · ¿Genéricos o interfaces?
Las dos cosas sirven para escribir código que vale para varios tipos. La regla corta:
Si el código hace lo mismo con cualquier tipo (filtrar, contar, buscar, guardar en un conjunto), usa genéricos.
Si cada tipo se comporta distinto (cada repositorio guarda a su manera, cada filtro acepta lo suyo), usa una interfaz.
Por eso RepositorioTareas es una interfaz (memoria y SQLite guardan distinto) y Filtrar es genérica (filtra igual una lista de tareas que una de números). En la práctica, los paquetes slices, maps y cmp de la biblioteca estándar te dan casi todo lo genérico que necesitas:
Gomain.go
package main
import (
"cmp""fmt""maps""slices"
)
typeTareastruct {
TitulostringPrioridadint
}
funcmain() {
tareas := []Tarea{
{Titulo: "Regar", Prioridad: 0},
{Titulo: "Pagar el alquiler", Prioridad: 2},
{Titulo: "Comprar pan", Prioridad: 1},
}
// En PHP: usort($tareas, fn($a, $b) => $b->prioridad <=> $a->prioridad);
slices.SortFunc(tareas, func(a, b Tarea) int {
return cmp.Compare(b.Prioridad, a.Prioridad)
})
fmt.Println(tareas[0].Titulo)
// En PHP: array_find_key($tareas, fn(Tarea $t) => $t->titulo === "Regar")
i := slices.IndexFunc(tareas, func(t Tarea) bool { return t.Titulo == "Regar" })
fmt.Println("Regar está en la posición", i)
porEtiqueta := map[string]int{"trabajo": 1, "casa": 2, "ocio": 0}
// En PHP: $claves = array_keys($porEtiqueta); sort($claves);
claves := slices.Sorted(maps.Keys(porEtiqueta))
fmt.Println(claves, slices.Contains(claves, "casa"))
}
Escribe la función genérica Filtrar, con el parámetro de tipo [T any], que recibe xs []T y f func(T) bool y devuelve un []T con los elementos de xs para los que f da true, en el mismo orden. Los tests la usan con tareas y con números. Es el array_values(array_filter()) de PHP con su @template T.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Declara var aceptados []T, recorre xs con range y haz append de cada x para el que f(x) sea true.
Reto 2 de 3 · ✓ Resuelto
Etiquetas sin repetir
Escribe la función genérica Unicos, con el parámetro de tipo [T comparable], que recibe xs []T, quita los repetidos y deja cada valor la primera vez que aparece, en el mismo orden. Por ejemplo Unicos([]string{"casa", "trabajo", "casa"}) devuelve [casa trabajo]. Debe servir también para Prioridad. Es el array_values(array_unique()) de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Como T es comparable, puede ser la clave de un map: vistos := map[T]bool{}. Recorre xs y añade x solo si !vistos[x].
Reto 3 de 3 · ✓ Resuelto
La tarea más prioritaria
Escribe la función genérica MaxPor, con los parámetros de tipo [T any, K cmp.Ordered], que recibe xs []T y clave func(T) K y devuelve (T, bool): el elemento con la clave más alta (si hay empate, el primero) y true; si xs está vacío, el valor cero y false. Por ejemplo, con clave = la prioridad, devuelve la tarea más urgente. Es un usort() + $xs[0] de PHP, pero sin ordenar todo y sin el null de la lista vacía.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Si len(xs) == 0, devuelve cero, false. Si no, empieza con mejor := xs[0] y recorre xs[1:]: cambia mejor cuando clave(x) > clave(mejor). Usa > y no >= para que en un empate gane el primero.
Resumen
Lo que te llevas de esta lección
func Filtrar[T any] es el @template T de PHPStan, pero lo comprueba el compilador.
Go deduce T por los argumentos; si no puede, lo escribes: NuevoConjunto[string].
La restricción dice qué puedes hacer con T: comparable para ==, cmp.Ordered para < (en PHP, @template T of …).
~int deja pasar tus tipos con int de base, como Prioridad.
Mismo código para todos los tipos → genéricos; comportamiento distinto por tipo → interfaz (en PHP, @template frente a implements).
Para recordarlo: «Molde, Restricción, Deducción»
MMolde [T any]
RRestricción [T comparable]
DDeducción Filtrar(tareas, f)
Un genérico es un Molde de galletas; la Restricción dice qué masa admite; y Go hace la Deducción de la masa sin que se lo digas. Y si dudas: «igual para todos, genérico; distinto para cada uno, interfaz».