Protocol Extension în Swift: ce este și cum să utilizezi

Ce este Protocol Extension?

Protocol Extension — este o modalitate de a adăuga implementarea metodelor și proprietăților calculate la un protocol existent. Fără extensions, protocolul definește doar cerințe, iar fiecare tip le implementează independent.

Protocol Extension rezolvă problema duplicării codului: dacă cinci structuri adoptă același protocol și implementează aceeași metodă, extension-ul oferă o implementare implicită o singură dată.

Conform Swift Evolution proposal SE-0186, protocol extensions sunt una dintre caracteristicile cheie care au determinat succesul POP. Acestea permit adăugarea unui comportament comun fără a crea clase de bază și fără a încălca principiul responsabilității unice.

Sintaxa protocol extension

Protocol Extension se declară ca un extension obișnuit, dar cu numele protocolului în locul tipului.

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

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

Acum orice tip care adoptă Greetable primește automat implementarea greet:

struct Person: Greetable {
    let name: String
}
// Person are automat greet()

let user = Person(name: "Alice")
print(user.greet()) // „Hello, Alice!“

Protocol Extension poate conține proprietăți calculate, dar nu stored properties (protocoalele nu pot defini stocare). De asemenea, poți adăuga subscript-uri și tipuri imbricate prin extension.

Implementarea metodelor implicite

Default implementation — utilizarea principală a protocol extension. Tipul poate suprascrie metoda, oferind propria versiune.

protocol Loggable {
    func log(message: String)
}

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

struct ConsoleLogger: Loggable {}
// Folosește implementarea implicită

struct FileLogger: Loggable {
    func log(message: String) {
        // Implementarea personalizată suprascrie cea implicită
        writeToFile(message)
    }
}

O diferență importantă față de moștenirea claselor: dacă tipul înseși implementează metoda protocolului, este apelată implementarea sa. Dacă nu — se utilizează cea implicită din extension. Aceasta este expediere statică, decizia fiind luată la compilare.

Restricții where în protocol extension

Where clause permite limitarea protocol extension-ului doar la acele tipuri care îndeplinesc condiții suplimentare. Este un mecanism puternic pentru adăugarea unui comportament specializat.

protocol Printable {
    var content: String { get }
}

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

Aici debugPrint este disponibil doar tipurilor care implementează simultan Printable și CustomStringConvertible. Biblioteca standard Swift utilizează pe scară largă acest model — de exemplu, extension pentru Collection where Element.

Sunt deosebit de utile where clauses cu restricția de egalitate a tipului:

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

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

Acest mecanism face protocol extension-ul selectiv: metoda commaJoined este disponibilă doar pentru colecțiile de șiruri, nu și pentru cele numerice. Compilatorul verifică restricțiile static.

Where constraints pot verifica:

• Conformitatea cu protocolul: where Self: Equatable
• Restricția tipului: where Element == String
• Combinații: where Element: Numeric, Element: Comparable

Acest lucru face din protocol extension un mecanism puternic pentru adăugarea unui comportament specializat fără a polua implementarea generală a protocolului.

Protocol Extensions vs moștenire

Mulți dezvoltatori se întreabă: când să folosească protocol extensions și când — moștenirea claselor? Răspunsul depinde de paradigma arhitecturală.

Apple recomandă să începi cu protocol + extension și să treci la clase doar atunci când ai nevoie de stare partajată sau identitate (reference semantics). Protocol extensions oferă compoziție în loc de moștenire — o abordare mai flexibilă și mai testabilă.

În practică, protocol extensions sunt adesea folosite pentru a adăuga metode wrapper convenabile peste cerințele protocolului. De exemplu, dacă protocolul necesită metoda validate cu un raport detaliat, extension-ul poate adăuga metoda isValid care returnează o valoare booleană pe baza versiunii complete. Acest lucru simplifică codul client fără a modifica contractul protocolului. Acest model se numește «default implementation cu derived API» și este utilizat pe scară largă în biblioteca standard Swift și în framework-uri terțe populare. Este una dintre tehnicile cheie ale programării orientate pe protocoale în acțiune și baza unei arhitecturi flexibile.