Protocol en Swift — qué es, sintaxis y capacidades

¿Qué es un Protocol en Swift?

Protocol es una interfaz abstracta que define lo que un tipo debe ser capaz de hacer, pero no cómo lo hace. En Swift, un protocolo es análogo a las interfaces en Java o Go, pero con capacidades adicionales.

Un protocolo puede requerir:

• Métodos de instancia y de tipo (estáticos)
• Propiedades con especificadores { get } o { get set }
• Inicializadores
• Subíndices
• Associated types (genéricos a nivel de protocolo)

Según la WWDC 2015, Apple introdujo la Programación Orientada a Protocolos como un enfoque fundamental para la arquitectura de aplicaciones Swift. A diferencia de la POO, donde la herencia de clases crea jerarquías rígidas, POP ofrece composición de protocolos. Esto brinda flexibilidad: un solo tipo puede cumplir con múltiples protocolos, obteniendo sus requisitos e implementaciones a través de extensiones.

Sintaxis de declaración de protocolos

Protocol se declara con la palabra clave protocol, un nombre y un cuerpo.

protocol Drawable {
    func draw(context: CGContext)
    var boundingBox: CGRect { get }
}

Un tipo adopta un protocolo mediante dos puntos después de su nombre:

struct Circle: Drawable {
    let center: CGPoint
    let radius: CGFloat

    func draw(context: CGContext) {
        context.addArc(center: center, radius: radius, ...)
    }

    var boundingBox: CGRect {
        CGRect(x: center.x - radius, y: center.y - radius,
               width: radius * 2, height: radius * 2)
    }
}

Un solo tipo puede adoptar múltiples protocolos separados por comas: struct MyType: ProtocolA, ProtocolB. El compilador verifica que se cumplan todos los requisitos de cada protocolo.

Requisitos de propiedades y métodos

Property requirements se declaran con la palabra clave var y los especificadores de acceso { get } o { get set }.

protocol UserProtocol {
    var name: String { get }
    var age: Int { get set }
    static var maxAge: Int { get }
    mutating func updateName(_ newName: String)
}

La palabra clave mutating en un protocolo indica que el método puede modificar self. Las estructuras deben implementar dicho método como mutating, mientras que las clases pueden omitirlo. Method requirements se declaran con una firma completa, incluidas las etiquetas de parámetros.

Herencia de protocolos

Protocol puede heredar de otro protocolo, añadiendo nuevos requisitos. Esto crea una jerarquía de contratos sin acoplamiento rígido a clases.

protocol Vehicle {
    var speed: Double { get set }
    func move()
}

protocol Flyable: Vehicle {
    var altitude: Double { get set }
    func takeOff()
}

Un tipo que adopta Flyable debe cumplir los requisitos de ambos protocolos — Vehicle y Flyable. Swift soporta herencia múltiple de protocolos: protocol A: B, C.

Protocol Composition

Protocol Composition es un mecanismo que permite especificar que un tipo debe cumplir con varios protocolos simultáneamente, sin crear un nuevo protocolo combinado.

func render(_ item: Drawable & Animatable) {
    item.draw(context: ...)
    item.animate(duration: 0.3)
}

La composición (&) funciona en parámetros de funciones, variables y restricciones genéricas. El compilador verifica que el tipo pasado simultáneamente satisfaga todos los protocolos. La composición se usa ampliamente en SwiftUI: some View es un genérico con composición.

Protocol Composition es preferible a crear una jerarquía de herencia: en lugar de protocol A: B, C, se puede adoptar B & C directamente. Esto brinda flexibilidad y reduce el acoplamiento. La composición es especialmente útil en parámetros de funciones y restricciones genéricas donde se necesita combinar temporalmente requisitos sin crear un protocolo intermedio. Esto reduce la cantidad de tipos auxiliares en el código.

Protocol como tipo

Protocol puede usarse como tipo de una variable, parámetro de función o elemento de colección. Esto se denomina tipo existencial.

var drawableItem: Drawable
let items: [Drawable] = [Circle(...), Rectangle(...)]

func process(drawables: [any Drawable]) {
    for item in drawables {
        item.draw(context: ...)
    }
}

La palabra clave any (Swift 5.6+) marca explícitamente un existencial. Sin any, el compilador emite una advertencia. Swift también soporta some (tipos opacos) para ocultar el tipo concreto detrás de un protocolo — este es un enfoque estándar en SwiftUI.

Errores comunes con protocolos

Al trabajar con protocolos, los desarrolladores suelen cometer varios errores recurrentes.

• Mutating olvidado — un método está marcado como mutating en el protocolo, pero una estructura lo implementa sin la palabra clave
• Protocol como tipo en lugar de genérico — usar Drawable en lugar de <T: Drawable> donde se necesita un tipo concreto
• Referencia circular de protocolo — un protocolo que se referencia a sí mismo a través de un associated type sin resolución adecuada
• Protocolo solo para clases — usar AnyObject innecesariamente, lo que excluye a struct y enum