Mis apuntes · Aprende Go desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 18 de 36 · Interfaces, composición y genéricos ✦ WebMCP implementado

Genéricos: lo que en PHP era @template

9 min de lectura 3 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.

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
<?php
declare(strict_types=1);

final readonly class Tarea
{
    public function __construct(
        public string $titulo,
        public bool $hecha = false,
    ) {}
}

/**
 * @template T
 * @param list<T> $xs
 * @param callable(T): bool $f
 * @return list<T>
 */
function filtrar(array $xs, callable $f): array
{
    return array_values(array_filter($xs, $f));
}

$tareas = [new Tarea("Comprar pan"), new Tarea("Repasar Go", hecha: true)];
$pendientes = filtrar($tareas, fn(Tarea $t): bool => !$t->hecha);

// PHP no lee el @template: solo PHPStan o Psalm lo comprueban.
echo count($pendientes) . PHP_EOL;
Gomain.go
package main

import "fmt"

type Tarea struct {
    Titulo string
    Hecha  bool
}

// [T any]: T es un tipo cualquiera que se decide al llamar.
// En PHP: /** @template T @param list<T> $xs @return list<T> */
func Filtrar[T any](xs []T, f func(T) bool) []T {
    var aceptados []T
    for _, x := range xs {
        if f(x) {
            aceptados = append(aceptados, x)
        }
    }
    return aceptados
}

func main() {
    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"

type Tarea struct {
    Titulo string
    Hecha  bool
}

func Filtrar[T any](xs []T, f func(T) bool) []T {
    var aceptados []T
    for _, x := range xs {
        if f(x) {
            aceptados = append(aceptados, x)
        }
    }
    return aceptados
}

// En PHP: array_map($f, $xs) con /** @template T @template U */
func Mapear[T, U any](xs []T, f func(T) U) []U {
    resultado := make([]U, 0, len(xs))
    for _, x := range xs {
        resultado = append(resultado, f(x))
    }
    return resultado
}

func main() {
    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 { return len(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
func Contiene[T any](xs []T, x T) bool {
    for _, v := range xs {
        if v == x {
            return true
        }
    }
    return false
}
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ónPermiteEn PHPStan
anyGuardar, pasar y devolver@template T
comparableAdemás == y !=; sirve de clave de un mapNo hay equivalente
cmp.OrderedAdemás <, >, <=, >= (números y strings)No hay equivalente
Una interfaz tuya (Describible)Llamar a sus métodos@template T of Describible
~int | ~float64Los operadores de los números (+, *…)@template T of int|float
Gomain.go
package main

import (
    "cmp"
    "fmt"
)

type Prioridad int

const (
    Baja Prioridad = iota
    Media
    Alta
)

// comparable: hace falta para usar ==
func Contiene[T comparable](xs []T, x T) bool {
    for _, v := range xs {
        if v == x {
            return true
        }
    }
    return false
}

// cmp.Ordered: hace falta para usar >. Con «comma ok» por si está vacío.
func Mayor[T cmp.Ordered](xs []T) (T, bool) {
    var mayor T
    if len(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 (~).
type Numero interface {
    ~int | ~float64
}

func Sumar[T Numero](xs []T) T {
    var total T
    for _, x := range xs {
        total += x
    }
    return total
}

func main() {
    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:

Tarea does not satisfy cmp.Ordered (Tarea missing in ~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | ~float32 | ~float64 | ~string)

4 · Tipos genéricos: tu Collection de verdad

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 es Pagina[Tarea], y meter otra cosa no compila:

Gomain.go
package main

import "fmt"

type Tarea struct {
    ID     int
    Titulo string
}

// 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.
type Conjunto[T comparable] struct {
    items map[T]struct{}
}

func NuevoConjunto[T comparable]() *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 {
    return len(c.items)
}

// Una página de resultados de cualquier cosa (tareas, usuarios…).
type Pagina[T any] struct {
    Items  []T
    Numero int
    Total  int
}

func main() {
    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.

PHPGoQuié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 []TEl compilador: no hay comentarios que puedan mentir
/** @var Collection<int, Tarea> */Pagina[Tarea], map[int]TareaEl compilador: meter otra cosa no compila
final class TareaCollection (una clase por tipo)Conjunto[T]: un tipo para todosSe escribe una vez y se usa con cualquier T
mixedany: acepta todo, pero pierde el tipoNadie: 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:

  1. Si el código hace lo mismo con cualquier tipo (filtrar, contar, buscar, guardar en un conjunto), usa genéricos.
  2. 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"
)

type Tarea struct {
    Titulo    string
    Prioridad int
}

func main() {
    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"))
}

Para seguir: el tutorial oficial de genéricos, la introducción del blog de Go y, para comparar, los genéricos de PHPStan y las plantillas de Psalm.

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

Filtrar[T] para todo

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

Resumen

Lo que te llevas de esta lección

  1. func Filtrar[T any] es el @template T de PHPStan, pero lo comprueba el compilador.
  2. Go deduce T por los argumentos; si no puede, lo escribes: NuevoConjunto[string].
  3. La restricción dice qué puedes hacer con T: comparable para ==, cmp.Ordered para < (en PHP, @template T of …).
  4. ~int deja pasar tus tipos con int de base, como Prioridad.
  5. 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».