Protocol in Swift — cos’è, sintassi e possibilità

Cos’è un Protocol in Swift?

Protocol è un’interfaccia astratta che definisce ciò che un tipo deve essere in grado di fare, ma non come lo fa. In Swift, un protocollo è analogo alle interfacce in Java o Go, ma con capacità aggiuntive.

Un protocollo può richiedere:

• Metodi di istanza e di tipo (statici)
• Proprietà con specificatori { get } o { get set }
• Inizializzatori
• Subscript
• Tipi associati (generici a livello di protocollo)

Secondo la WWDC 2015, Apple ha introdotto la programmazione orientata ai protocolli come approccio fondamentale per l’architettura delle applicazioni Swift. A differenza della OOP, dove l’ereditarietà delle classi crea gerarchie rigide, la POP offre la composizione di protocolli. Ciò offre flessibilità: un singolo tipo può conformarsi a più protocolli, ottenendo i loro requisiti e implementazioni tramite estensioni.

Sintassi di dichiarazione dei protocolli

Protocol viene dichiarato con la parola chiave protocol, un nome e un corpo.

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

Un tipo adotta un protocollo usando due punti dopo il suo 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)
    }
}

Un singolo tipo può adottare più protocolli separati da virgole: struct MyType: ProtocolA, ProtocolB. Il compilatore verifica che tutti i requisiti di ciascun protocollo siano soddisfatti.

Requisiti di proprietà e metodi

Requisiti di proprietà sono dichiarati con la parola chiave var e gli specificatori di accesso { 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 parola chiave mutating in un protocollo indica che il metodo può modificare self. Le strutture devono implementare tale metodo come mutating, mentre le classi possono ometterlo. Requisiti di metodi sono dichiarati con una firma completa, incluse le etichette dei parametri.

Ereditarietà dei protocolli

Protocol può ereditare un altro protocollo, aggiungendo nuovi requisiti. Ciò crea una gerarchia di contratti senza un accoppiamento rigido alle classi.

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

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

Un tipo che adotta Flyable deve soddisfare i requisiti di entrambi i protocolli — Vehicle e Flyable. Swift supporta l’ereditarietà multipla di protocolli: protocol A: B, C.

Protocol Composition

Protocol Composition è un meccanismo che permette di specificare che un tipo deve conformarsi a più protocolli simultaneamente, senza creare un nuovo protocollo combinato.

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

La composizione (&) funziona nei parametri di funzioni, variabili e vincoli generici. Il compilatore verifica che il tipo passato simultaneamente soddisfi tutti i protocolli. La composizione è ampiamente utilizzata in SwiftUI: some View è un generico con composizione.

Protocol Composition è preferibile alla creazione di una gerarchia di ereditarietà: invece di protocol A: B, C, si può adottare direttamente B & C. Ciò offre flessibilità e riduce l’accoppiamento. La composizione è particolarmente utile nei parametri di funzioni e vincoli generici dove è necessario combinare temporaneamente requisiti senza creare un protocollo intermedio. Ciò riduce il numero di tipi ausiliari nel codice.

Protocollo come tipo

Protocol può essere usato come tipo di una variabile, parametro di funzione o elemento di collezione. Questo è chiamato tipo esistenziale.

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

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

La parola chiave any (Swift 5.6+) marca esplicitamente un esistenziale. Senza any, il compilatore emette un avviso. Swift supporta anche some (tipi opachi) per nascondere il tipo concreto dietro un protocollo — questo è un approccio standard in SwiftUI.

Errori comuni con i protocolli

Quando si lavora con i protocolli, gli sviluppatori commettono spesso diversi errori ricorrenti.

• Mutating dimenticato — un metodo è marcato come mutating nel protocollo, ma una struttura lo implementa senza la parola chiave
• Protocollo come tipo invece di generico — usare Drawable invece di <T: Drawable> dove serve un tipo concreto
• Riferimento circolare di protocollo — un protocollo che si riferisce a sé stesso attraverso un tipo associato senza risoluzione corretta
• Protocollo solo per classi — usare AnyObject inutilmente, escludendo struct ed enum