Restricciones recursivas y genéricos de orden superior
Escriba restricciones recursivas (por ejemplo, secuencias anidadas) y funciones genéricas de orden superior que acepten closures o funciones genéricas.
Restricciones recursivas y genéricos de orden superior es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 3 lecciones en total.
Qué es y por qué
En esta lección se muestran:
- Restricciones recursivas: restricciones sobre miembros genéricos anidados (por ejemplo, Sequence de Sequence).
- Genéricos de orden superior: funciones genéricas que aceptan cierres o funciones genéricos.
Secuencias anidadas (aplanar)
Una restricción recursiva clásica: requerimos C.Element: Sequence para poder iterar hasta dos niveles de profundidad.
// Works for any Collection whose elements are Sequences
func flatten<C: Collection>(_ c: C) -> [C.Element.Element]
where C.Element: Sequence {
var result: [C.Element.Element] = []
result.reserveCapacity(c.reduce(0) { $0 + ($1 as AnySequence<C.Element.Element>).underestimatedCount })
for inner in c {
for e in inner { result.append(e) }
}
return result
}
let nested = [[1,2], [3], [4,5]]
print(flatten(nested)) // [1,2,3,4,5]Mapear genéricamente elementos anidados
Aplicamos dos restricciones: C: Collection y C.Element: Collection, lo que permite llamar a map en cada nivel.
// Map over a two-level structure without fixing concrete types
func mapNested<C: Collection, R>(_ c: C, _ transform: (C.Element.Element) -> R) -> [[R]]
where C.Element: Collection {
return c.map { inner in inner.map(transform) }
}
let doubled = mapNested([[1,2],[3]], { $0 * 2 })
print(doubled) // [[2,4],[6]]compose(f,g)
Genéricos de orden superior: la función es genérica respecto a las propias funciones y permite crear pipelines reutilizables como compose.
// Compose two generic transforms that work on the same element type
func compose<A, B, C>(
_ f: @escaping (B) -> C,
_ g: @escaping (A) -> B
) -> (A) -> C {
{ a in f(g(a)) }
}
let toString: (Int) -> String = { "\\($0)" }
let length: (String) -> Int = { $0.count }
let intToLen = compose(length, toString)
print(intToLen(1234)) // 4Parámetros de cierres genéricos
El cierre f también es un parámetro genérico. Mantenemos los tipos flexibles mediante restricciones where.
// A generic "transform each" that accepts ANY transform (generic in T/U)
func transformEach<T, U, C: Collection>(_ c: C, using f: (T) -> U) -> [U]
where C.Element == T {
var out: [U] = []
out.reserveCapacity(c.count)
for x in c { out.append(f(x)) }
return out
}
let words = ["swift","kit"]
print(transformEach(words, using: { $0.uppercased() })) // ["SWIFT","KIT"]Directrices
Consejos:
- Escriba las restricciones mínimas que necesite (
Sequencefrente aCollection). - Prefiera las cláusulas where para mejorar la legibilidad.
- Pruebe con varios tipos concretos para garantizar la generalidad.
- Documente las suposiciones (por ejemplo, el orden y la unicidad de los elementos).
Definición de genéricos de orden superior
Comprobación rápida: ¿Qué hace que una función sea una función genérica de orden superior?
Repaso
Repaso: Use restricciones recursivas (por ejemplo, C.Element: Sequence) para trabajar con genéricos anidados; use genéricos de orden superior para componer de forma clara pipelines de funciones reutilizables.
Preguntas frecuentes
¿La lección «Restricciones recursivas y genéricos de orden superior» es gratis?
Sí — el texto completo de «Restricciones recursivas y genéricos de orden superior» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 3 lecciones en total.
¿Qué aprenderé en «Restricciones recursivas y genéricos de orden superior»?
Escriba restricciones recursivas (por ejemplo, secuencias anidadas) y funciones genéricas de orden superior que acepten closures o funciones genéricas. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Swift Academy?
No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.
¿Cuánto tiempo toma la lección «Restricciones recursivas y genéricos de orden superior»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Swift Academy?
Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Conformidades condicionales
- Restricciones recursivas y genéricos de orden superior
- Cláusulas where en extensiones