Composición y refinamiento: combinar protocolos y acotar extensiones

Un protocolo aislado es útil; un sistema de protocolos que se refinan, se combinan y se activan condicionalmente es una herramienta de expresividad de otro orden. Swift ofrece un pequeño álgebra de contratos: puedes construir uno más exigente sobre otros —refinamiento—, puedes exigir varios a la vez sin crear ninguno nuevo —composición—, y puedes hacer que una extension entregue comportamiento solo a los conformantes que además cumplan una condición. Con esas tres operaciones, la biblioteca estándar describe toda la jerarquía de secuencias y colecciones sin una sola clase.

Refinar: un contrato sobre otro

Un protocolo puede heredar de otros. El resultado es un contrato más exigente: quien lo firme debe cumplir todo lo suyo y todo lo de sus padres.

protocol Identificable {
    var id: String { get }
}

protocol Persistible: Identificable, Codable {
    static var tabla: String { get }
    func guardar() throws
}

Conformar a Persistible obliga a aportar id, la conformidad a Codable y los dos miembros nuevos. Al revés no vale: quien conforme a Identificable no gana nada de Persistible.

Un refinamiento puede además restringir la categoría del conformante:

protocol Observable: AnyObject {
    func alCambiar()
}

AnyObject limita la conformidad a tipos por referencia. Es la forma correcta de expresar que la abstracción depende de la identidad y no del valor —un observador debe ser el mismo objeto entre notificaciones—, y también lo que permite guardar referencias weak a él.

La biblioteca estándar es una cascada de refinamientos: Collection refina Sequence, BidirectionalCollection refina Collection, RandomAccessCollection refina la anterior. Cada escalón añade garantías —poder recorrer varias veces, poder retroceder, poder saltar en tiempo constante— y cada algoritmo se escribe pidiendo exactamente el escalón que necesita.

Componer con el operador ampersand

Cuando quieres exigir dos contratos a la vez pero no tiene sentido crear un tercero, los compones:

func registrar(_ objeto: Identificable & Codable) { }

func mostrar(_ dato: some Equatable & CustomStringConvertible) { }

typealias Entidad = Identificable & Codable & Hashable

La composición es anónima y estructural: no define un nuevo nombre en el sistema de tipos ni obliga a nadie a declarar nada. Cualquier tipo que ya cumpla ambas partes encaja sin tocar su declaración. El typealias solo pone etiqueta a la conjunción por comodidad de lectura.

Extensiones acotadas con where

Aquí la composición se vuelve dinámica en el sentido del diseño: una extension puede aplicarse solo a la parte de los conformantes que cumpla una condición extra.

protocol Contenedor {
    associatedtype Elemento
    var items: [Elemento] { get }
}

extension Contenedor {
    var cuenta: Int { items.count }                 // para todos
}

extension Contenedor where Elemento: Numeric {
    var total: Elemento { items.reduce(.zero, +) }  // solo si el elemento suma
}

extension Contenedor where Elemento: Equatable {
    func contiene(_ x: Elemento) -> Bool { items.contains(x) }
}

Un contenedor de Int obtiene cuenta, total y contiene; uno de una struct sin conformidades obtiene solo cuenta. El miembro no está oculto ni deshabilitado: no existe para ese tipo, y llamarlo es un error de compilación con un mensaje que nombra la restricción incumplida.

La condición también puede recaer sobre Self, lo que permite que un protocolo aporte comportamiento apoyándose en otro sin heredar de él:

extension Contenedor where Self: Identificable {
    var etiqueta: String { "\(id): \(cuenta) items" }
}

Y el mismo mecanismo, aplicado a la declaración de conformidad, produce la conformidad condicional: un tipo genérico conforma solo cuando su parámetro lo hace.

struct Caja<T> { let contenido: [T] }

extension Caja: Equatable where T: Equatable { }

Es exactamente la regla que hace que [Int] sea Equatable y [Any] no lo sea, sin que exista un array especial para los tipos comparables.

flowchart TB
seq[Sequence recorrer una vez] --> col[Collection indices estables]
col --> bid[BidirectionalCollection retroceder]
bid --> rac[RandomAccessCollection salto constante]
col --> ext1[extension where Element es Equatable]
col --> ext2[extension where Element es Numeric]
ext1 --> m1[metodos de busqueda]
ext2 --> m2[metodos de suma y media]

El álgebra completa