Swift Academy · Lección

Restricción de tipos asociados

Limite los tipos asociados en contextos genéricos.

Restricción de tipos asociados es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 de 4. 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 4 lecciones en total.

Resumen de tipos asociados

Un protocolo puede declarar un tipo asociado con associatedtype, que actúa como marcador de posición que el tipo que conforma debe definir. Element en un protocolo de contenedor es el ejemplo clásico.

protocol Container {
    associatedtype Item
    var count: Int { get }
    func item(at i: Int) -> Item
}

Conformidad con un tipo concreto

Un tipo que conforma fija el tipo asociado, que a menudo se infiere a partir de cómo se utiliza.

protocol Container {
    associatedtype Item
    func item(at i: Int) -> Item
}
struct IntBox: Container {
    let values: [Int]
    func item(at i: Int) -> Int { values[i] }
}
print(IntBox(values: [10, 20]).item(at: 1))

Restricción del tipo asociado

Añada una restricción directamente en la declaración: associatedtype Item: Comparable obliga a que el tipo de elemento de cada tipo que conforme admita comparaciones.

protocol Sorted {
    associatedtype Item: Comparable
    var items: [Item] { get }
}
struct Nums: Sorted { let items: [Int] }
print(Nums(items: [3, 1, 2]).items.sorted())

Uso de la restricción

Como el tipo asociado está restringido, las extensiones de protocolos pueden basarse en esa capacidad.

protocol Sorted {
    associatedtype Item: Comparable
    var items: [Item] { get }
}
extension Sorted {
    var smallest: Item? { items.min() }
}
struct Nums: Sorted { let items: [Int] }
print(Nums(items: [5, 2, 8]).smallest!)

where en associatedtype

Swift también permite incluir una cláusula where en un tipo asociado para relacionarlo con otro tipo asociado o con un tipo anidado.

protocol Sequence2 {
    associatedtype Element
    associatedtype Iterator: IteratorProtocol where Iterator.Element == Element
}

Restricción a otro protocolo

Se puede exigir que un tipo asociado conforme con un protocolo definido por usted, incorporando comportamiento por capas.

protocol HasName { var name: String { get } }
protocol Registry {
    associatedtype Entry: HasName
    var entries: [Entry] { get }
}
struct User: HasName { let name: String }
struct Users: Registry { let entries: [User] }
print(Users(entries: [User(name: "Ada")]).entries[0].name)

Varios tipos asociados

Un protocolo puede declarar varios tipos asociados, cada uno con sus propias restricciones.

protocol Mapping {
    associatedtype Key: Hashable
    associatedtype Value
    func value(for k: Key) -> Value?
}
struct Phonebook: Mapping {
    let data: [String: Int]
    func value(for k: String) -> Int? { data[k] }
}
print(Phonebook(data: ["x": 1]).value(for: "x")!)

Tipo asociado predeterminado

Puede asignar un valor predeterminado a un tipo asociado mediante =, que se utiliza cuando el tipo que conforma no lo especifica de otro modo.

protocol Producer {
    associatedtype Output = String
    func make() -> Output
}
struct Hello: Producer {
    func make() -> String { "hi" }
}
print(Hello().make())

Las restricciones habilitan algoritmos genéricos

Con un tipo asociado restringido, una extensión de protocolo puede implementar algoritmos reales compartidos por todos los tipos que conforman.

protocol Scored {
    associatedtype Score: Comparable
    var scores: [Score] { get }
}
extension Scored {
    var best: Score? { scores.max() }
}
struct Game: Scored { let scores: [Int] }
print(Game(scores: [10, 40, 25]).best!)

Restricciones de igualdad de tipos en extensiones

Fuera del protocolo, puede restringir aún más el tipo asociado al extender el protocolo.

protocol Box2 {
    associatedtype Content
    var content: Content { get }
}
extension Box2 where Content == Int {
    var doubled: Int { content * 2 }
}
struct IB: Box2 { let content: Int }
print(IB(content: 7).doubled)

¿Por qué restringir?

Restringir los tipos asociados permite que los protocolos sigan siendo genéricos y potentes: la restricción es una promesa en la que pueden confiar la extensión y quienes la llaman.

protocol Listy {
    associatedtype E: Equatable
    var elements: [E] { get }
}
extension Listy {
    func has(_ x: E) -> Bool { elements.contains(x) }
}
struct L: Listy { let elements: [String] }
print(L(elements: ["a", "b"]).has("b"))

Comprobación rápida

Compruebe su comprensión de las restricciones de los tipos asociados.

Resumen

Puede restringir los tipos asociados directamente (associatedtype Item: Comparable), relacionarlos mediante cláusulas where, exigir la conformidad con un protocolo, proporcionar valores predeterminados con =, declarar varios tipos asociados y perfeccionarlos en extensiones. Las restricciones permiten que las extensiones de protocolos implementen algoritmos compartidos y seguros para los tipos.

Preguntas frecuentes

¿La lección «Restricción de tipos asociados» es gratis?

Sí — el texto completo de «Restricción de tipos asociados» 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 4 lecciones en total.

¿Qué aprenderé en «Restricción de tipos asociados»?

Limite los tipos asociados en contextos genéricos. 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 3 de 4.

¿Cuánto tiempo toma la lección «Restricción de tipos asociados»?

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

← Volver a Swift Academy