Genéricos variádicos: parameter packs y each

Durante años, cada vez que una API necesitaba aceptar un número arbitrario de argumentos de tipos distintos, la respuesta era la misma: escribir la sobrecarga para dos, para tres, para cuatro, y rendirse en diez. Los packs de parámetros acaban con eso. Una sola declaración, cualquier aridad, tipos heterogéneos y seguridad completa. Es la incorporación más ambiciosa al sistema genérico desde su diseño original.

La aritmética de las sobrecargas

Antes de los packs, el sistema genérico solo sabía hablar de un número fijo de parámetros de tipo. Una función que combinara dos secuencias necesitaba dos marcadores; una que combinara tres, tres declaraciones distintas. La consecuencia está por todas partes: la función de la librería estándar que empareja secuencias solo acepta dos, los combinadores reactivos se detienen en cuatro y los constructores de vistas de SwiftUI mantenían una torre de sobrecargas hasta diez hijos, cada una idéntica salvo por la cuenta.

// La forma vieja: una declaracion por aridad, para siempre
func juntar<A, B>(_ a: A, _ b: B) -> String { "\(a)\(b)" }
func juntar<A, B, C>(_ a: A, _ b: B, _ c: C) -> String { "\(a)\(b)\(c)" }
func juntar<A, B, C, D>(_ a: A, _ b: B, _ c: C, _ d: D) -> String { "\(a)\(b)\(c)\(d)" }

El parámetro variádico clásico no resuelve el problema porque es homogéneo: obliga a que todos los argumentos compartan un único tipo, y para admitir tipos distintos hay que borrarlos a un existencial, perdiendo exactamente la información que querías conservar.

Declarar y expandir

Un pack de tipos se declara anteponiendo each al nombre del parámetro genérico. Un pack de valores se declara aplicando repeat al pack de tipos en la posición del parámetro. La expansión, tanto en tipos como en expresiones, se escribe también con repeat seguido de un patrón que menciona los packs con each.

func imprimirTodos<each T>(_ valores: repeat each T) {
    for valor in repeat each valores {
        print(valor)
    }
}

imprimirTodos(1, "dos", 3.0, true)

Fíjate en la simetría: each T nombra el pack de tipos, repeat each T es el tipo del parámetro, repeat each valores expande el pack de valores. El bucle se despliega en compilación, de modo que cada iteración se comprueba con el tipo concreto de esa posición, no con un existencial.

La expansión también funciona en posición de tipo, y ahí es donde el mecanismo empieza a lucir: puedes devolver una tupla cuyo número de componentes depende de la aridad de la llamada.

struct Caja<Valor> {
    let valor: Valor
}

func enCajas<each T>(_ valores: repeat each T) -> (repeat Caja<each T>) {
    (repeat Caja(valor: each valores))
}

let r = enCajas(1, "dos")   // tipo: (Caja<Int>, Caja<String>)

flowchart TD
A[Pack de tipos each T] --> B[Parametro de valor repeat each T]
B --> C[Patron de expansion con repeat]
C --> D[Expansion en llamadas]
C --> E[Expansion en tuplas]
C --> F[Expansion en bucle desplegado]
D --> G[Aridad libre y tipos conservados]
E --> G
F --> G
style G fill:#a6e3a1,color:#11111b

Restringir un pack

Un pack se restringe igual que cualquier parámetro genérico, y la restricción se aplica a todos sus elementos. La sintaxis de dos puntos funciona directamente, y la cláusula where admite la forma con expansión cuando la condición es más elaborada.

func codificarTodos<each T: Encodable>(_ valores: repeat each T) throws -> [Data] {
    var salida: [Data] = []
    let codificador = JSONEncoder()
    for valor in repeat each valores {
        salida.append(try codificador.encode(valor))
    }
    return salida
}

func sonIguales<each T: Equatable>(
    _ a: repeat each T, _ b: repeat each T
) -> Bool {
    for (x, y) in repeat (each a, each b) {
        if x != y { return false }
    }
    return true
}

El segundo ejemplo muestra el patrón de expansión con dos packs a la vez: repeat (each a, each b) produce la secuencia de pares posición a posición, y el compilador exige que ambos tengan la misma forma. Esa comprobación es estática, no una aserción en ejecución.

Cuándo usarlos y cuándo no

Los packs son la herramienta correcta cuando la aridad es variable y los tipos son heterogéneos y quieres conservarlos. Si alguna de las tres condiciones falla, hay opciones más simples y más legibles.

• Tipos homogéneos. Un array o un variádico clásico expresa lo mismo con menos maquinaria y mejores diagnósticos.
• Aridad fija y pequeña. Dos o tres sobrecargas explícitas siguen siendo más claras que un pack, sobre todo en API pública que otros van a leer.
• Los tipos no importan. Si vas a borrarlos a un existencial de todas formas, el pack no aporta nada.

Cuando sí encajan, la ganancia es doble: desaparece la torre de sobrecargas y desaparecen sus límites arbitrarios. Ya no hay una API que funciona con diez elementos y falla con once porque nadie escribió esa línea.

Los casos donde el mecanismo brilla comparten una silueta reconocible: constructores de resultados que combinan fuentes heterogéneas, envoltorios que transforman cada componente conservando su tipo, y adaptadores que reciben una lista de dependencias distintas y las inyectan. En todos ellos, el tipo del resultado es una función del tipo de las entradas, y esa función es exactamente lo que un patrón de expansión sabe expresar.

// Adaptador: transforma cada componente y conserva la aridad y los tipos
func mapear<each Entrada, each Salida>(
    _ valores: repeat each Entrada,
    con transformar: (repeat (each Entrada) -> each Salida)
) -> (repeat each Salida) {
    (repeat (each transformar)(each valores))
}

Léelo con la anatomía de la lección 1: dos packs de tipos, un pack de valores, un pack de funciones y un patrón de expansión que los consume a la vez. La igualdad de forma entre los tres es lo que hace que la firma sea segura.