Protocol Extension em Swift: o que é e como usar

O que é Protocol Extension?

Protocol Extension é uma maneira de adicionar implementações de métodos e propriedades computadas a um protocolo existente. Sem extensões, um protocolo apenas define requisitos, e cada tipo os implementa individualmente.

Protocol Extension resolve o problema de duplicação de código: se cinco structs adotam o mesmo protocolo e implementam o mesmo método, a extensão fornece a implementação padrão uma vez.

De acordo com Swift Evolution proposal SE-0186, protocol extensions são um dos recursos-chave que predeterminaram o sucesso do POP. Elas permitem adicionar comportamento comum sem criar classes base e sem violar o princípio de responsabilidade única.

Sintaxe do protocol extension

Uma Protocol Extension é declarada como uma extensão regular, mas com o nome do protocolo em vez de um tipo.

protocol Greetable {
    var name: String { get }
    func greet() -> String
}

extension Greetable {
    func greet() -> String {
        return "Hello, \(name)!"
    }
}

Agora qualquer tipo que adote Greetable obtém automaticamente a implementação de greet:

struct Person: Greetable {
    let name: String
}
// Person automaticamente tem greet()

let user = Person(name: "Alice")
print(user.greet()) // "Olá, Alice!"

Uma Protocol Extension pode conter propriedades computadas, mas não propriedades armazenadas (protocolos não podem definir armazenamento). Você também pode adicionar subscritos e tipos aninhados por meio de extensões.

Implementações de métodos padrão

A implementação padrão é o uso principal da protocol extension. Um tipo pode sobrescrever o método fornecendo sua própria versão.

protocol Loggable {
    func log(message: String)
}

extension Loggable {
    func log(message: String) {
        print("[Default] \(message)")
    }
}

struct ConsoleLogger: Loggable {}
// Usa implementação padrão

struct FileLogger: Loggable {
    func log(message: String) {
        // Implementação personalizada substitui o padrão
        writeToFile(message)
    }
}

Uma diferença importante da herança de classes: se o próprio tipo implementa o método do protocolo, sua implementação é chamada. Caso contrário, o padrão da extensão é usado. Isso é despacho estático — a decisão é tomada em tempo de compilação.

Restrições where em protocol extension

Uma cláusula where permite restringir uma protocol extension apenas aos tipos que atendem a condições adicionais. Este é um mecanismo poderoso para adicionar comportamento especializado.

protocol Printable {
    var content: String { get }
}

extension Printable where Self: CustomStringConvertible {
    func debugPrint() -> String {
        return "[Printable] \(content)"
    }
}

Aqui, debugPrint está disponível apenas para tipos que implementam simultaneamente Printable e CustomStringConvertible. A biblioteca padrão do Swift faz uso extensivo desse padrão — por exemplo, extensões para Collection where Element.

Cláusulas where com restrições de igualdade de tipo são especialmente úteis:

extension Collection where Element == String {
    func commaJoined() -> String {
        return self.joined(separator: ", ")
    }
}

let words = ["Swift", "Kotlin", "Java"]
print(words.commaJoined()) // "Swift, Kotlin, Java"

Esse mecanismo torna a protocol extension seletiva: o método commaJoined está disponível apenas para coleções de strings, não para coleções numéricas. O compilador verifica as restrições estaticamente.

As restrições where podem verificar:

• Conformidade com um protocolo: where Self: Equatable
• Restrição de tipo: where Element == String
• Combinações: where Element: Numeric, Element: Comparable

Isso torna a protocol extension um mecanismo poderoso para adicionar comportamento especializado sem poluir a implementação geral do protocolo.

Protocol Extensions vs herança

Muitos desenvolvedores se perguntam: quando usar protocol extensions e quando usar herança de classes? A resposta depende do paradigma arquitetônico.

A Apple recomenda começar com protocol + extension e mudar para classes apenas quando for necessário estado compartilhado ou identidade (semântica de referência). Protocol extensions fornecem composição em vez de herança — uma abordagem mais flexível e testável.

Na prática, protocol extensions são frequentemente usadas para adicionar métodos wrapper convenientes sobre os requisitos do protocolo. Por exemplo, se um protocolo requer um método validate com um relatório detalhado, a extensão pode adicionar o método isValid que retorna um valor booleano com base na versão completa. Isso simplifica o código do cliente sem alterar o contrato do protocolo. Esse padrão é chamado de “implementação padrão com API derivada” e é amplamente usado na biblioteca padrão do Swift e em frameworks de terceiros populares. É uma das principais técnicas da programação orientada a protocolos em ação e a base de uma arquitetura flexível.