Protocol em Swift — o que é, sintaxe e possibilidades

O que é Protocol em Swift?

Protocol é uma interface abstrata que define o que um tipo deve ser capaz de fazer, mas não como ele faz. Em Swift, um protocolo é análogo às interfaces em Java ou Go, mas com capacidades adicionais.

Um protocolo pode exigir:

• Métodos de instância e de tipo (estáticos)
• Propriedades com especificadores { get } ou { get set }
• Inicializadores
• Subscritos
• Tipos associados (genéricos a nível de protocolo)

De acordo com a WWDC 2015, a Apple introduziu a Programação Orientada a Protocolos como uma abordagem fundamental para a arquitetura de aplicações Swift. Ao contrário da POO, onde a herança de classes cria hierarquias rígidas, a POP oferece composição de protocolos. Isto proporciona flexibilidade: um único tipo pode estar em conformidade com vários protocolos, obtendo seus requisitos e implementações através de extensões.

Sintaxe de declaração de protocolos

Protocol é declarado com a palavra-chave protocol, um nome e um corpo.

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

Um tipo adota um protocolo usando dois pontos após seu nome:

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)
    }
}

Um único tipo pode adotar vários protocolos separados por vírgulas: struct MyType: ProtocolA, ProtocolB. O compilador verifica se todos os requisitos de cada protocolo foram cumpridos.

Requisitos de propriedades e métodos

Requisitos de propriedades são declarados com a palavra-chave var e os especificadores de acesso { get } ou { get set }.

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

A palavra-chave mutating em um protocolo indica que o método pode modificar self. As estruturas devem implementar tal método como mutating, enquanto as classes podem omiti-lo. Requisitos de métodos são declarados com uma assinatura completa, incluindo rótulos de parâmetros.

Herança de protocolos

Protocol pode herdar de outro protocolo, adicionando novos requisitos. Isto cria uma hierarquia de contratos sem acoplamento rígido a classes.

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

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

Um tipo que adota Flyable deve cumprir os requisitos de ambos os protocolos — Vehicle e Flyable. Swift suporta herança múltipla de protocolos: protocol A: B, C.

Protocol Composition

Protocol Composition é um mecanismo que permite especificar que um tipo deve estar em conformidade com vários protocolos simultaneamente, sem criar um novo protocolo combinado.

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

A composição (&) funciona em parâmetros de funções, variáveis e restrições genéricas. O compilador verifica que o tipo passado simultaneamente satisfaz todos os protocolos. A composição é amplamente usada em SwiftUI: some View é um genérico com composição.

Protocol Composition é preferível a criar uma hierarquia de herança: em vez de protocol A: B, C, pode-se adotar B & C diretamente. Isto proporciona flexibilidade e reduz o acoplamento. A composição é especialmente útil em parâmetros de funções e restrições genéricas onde é necessário combinar temporariamente requisitos sem criar um protocolo intermediário. Isto reduz o número de tipos auxiliares no código.

Protocolo como tipo

Protocol pode ser usado como tipo de uma variável, parâmetro de função ou elemento de coleção. Isto é chamado de tipo existencial.

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

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

A palavra-chave any (Swift 5.6+) marca explicitamente um existencial. Sem any, o compilador emite um aviso. Swift também suporta some (tipos opacos) para ocultar o tipo concreto atrás de um protocolo — esta é uma abordagem padrão em SwiftUI.

Erros comuns com protocolos

Ao trabalhar com protocolos, os desenvolvedores frequentemente cometem vários erros recorrentes.

• Mutating esquecido — um método está marcado como mutating no protocolo, mas uma estrutura o implementa sem a palavra-chave
• Protocolo como tipo em vez de genérico — usar Drawable em vez de <T: Drawable> onde um tipo concreto é necessário
• Referência circular de protocolo — um protocolo que referencia a si mesmo através de um tipo associado sem resolução adequada
• Protocolo apenas para classes — usar AnyObject desnecessariamente, o que exclui struct e enum