Associated Values in Swift: cosa sono, sintassi ed esempi

Cosa sono gli Associated Values?

Associated Values sono informazioni aggiuntive che un caso di enum può memorizzare con sé. A differenza dei raw values, che sono fissi a livello di dichiarazione, gli associated values vengono impostati quando si crea un'istanza di enum.

Immagina di modellare un metodo di pagamento: il caso creditCard può memorizzare le ultime 4 cifre e la data di scadenza, mentre il caso applePay non memorizza nulla. Con gli associated values, questo viene implementato naturalmente, senza sottoclassi o campi opzionali.

Secondo la documentazione Apple, gli associated values trasformano un enum da un semplice insieme di costanti in un tipo di dato algebrico (sum type), caratteristico dei linguaggi funzionali. Ciò aumenta significativamente l'espressività del codice.

Sintassi degli associated values

Gli Associated Values vengono dichiarati tra parentesi dopo il caso, specificando nomi e tipi dei parametri, come nelle funzioni.

enum MediaFile {
    case image(width: Int, height: Int, format: String)
    case video(duration: Double, codec: String)
    case audio(bitrate: Int)
    case unknown
}

Quando si crea un'istanza, gli associated values vengono passati come argomenti:

let photo = MediaFile.image(width: 1920, height: 1080, format: "jpeg")
let clip = MediaFile.video(duration: 120.5, codec: "h264")

Swift non impone restrizioni sul numero o sui tipi di associated values. Puoi usare generics, funzioni di chiusura e altri enum all'interno degli associated values. Ciò consente di costruire strutture nidificate complesse.

I nomi dei parametri degli associated values vengono usati come etichette degli argomenti quando si crea un'istanza — questo migliora la leggibilità del codice. Durante l'estrazione tramite switch, i nomi servono come documentazione, chiarendo il significato di ogni valore. Questo approccio rende il codice auto-documentante e riduce la probabilità di errori durante il matching dei dati. Ciò è particolarmente prezioso nello sviluppo di team di grandi applicazioni iOS.

Switch con associated values

Switch è il modo principale per estrarre gli associated values. I valori vengono legati a costanti o variabili tramite let o var.

func describe(_ file: MediaFile) -> String {
    switch file {
    case .image(let w, let h, let fmt):
        return "Image \(w)x\(h) .\(fmt)"
    case .video(let duration, let codec):
        return "Video \(duration)s, \(codec)"
    case .audio(let bitrate):
        return "Audio \(bitrate)kbps"
    case .unknown:
        return "Unknown format"
    }
}

Swift supporta il matching parziale — puoi specificare valori concreti per gli associated values:

switch file {
case .image(let w, let h, "png"):
    print("Immagine PNG \(w)x\(h)")
case .image(1920, 1080, _):
    print("Immagine Full HD")
default:
    break
}

Usare un wildcard (_) consente di ignorare associated values non necessari, e le costanti nei casi permettono di verificare corrispondenze con valori specifici.

Associated Values vs Raw Values

Molti sviluppatori principianti confondono gli associated values con i raw values. Sono meccanismi diversi con casi d'uso diversi.

Secondo Swift Evolution, gli associated values sono stati introdotti in Swift 2.0 come parte del redesign degli enum. Forniscono un approccio algebrico ai tipi, dove ogni caso è un costruttore separato con la propria firma.

Esempi pratici di associated values

Gli Associated Values sono attivamente utilizzati in progetti iOS reali. Consideriamo tre scenari tipici.

Modellazione di risposte API

enum APIResponse<T: Codable> {
    case success(data: T, cached: Bool)
    case failure(error: Error, retryAvailable: Bool)
    case loading(progress: Double)
}

Macchina a Stati UI

enum ViewState<T> {
    case idle
    case loading(message: String)
    case loaded(data: T)
    case error(message: String, retryAction: () -> Void)
}

Con gli associated values, l'enum diventa un potente strumento per le macchine a stati: ogni caso è uno stato, gli associated values sono i parametri di quello stato. Il compilatore garantisce che tutte le transizioni siano gestite.

Estrazione tramite if case e guard case

Per verificare un singolo caso senza switch, usa if case o guard case. È più compatto quando devi gestire una sola opzione.

let error = NetworkError.timeout(seconds: 30)

if case .timeout(let seconds) = error {
    print("Richiesta scaduta dopo \(seconds)s")
}

guard case .httpError(let code, _) = error else {
    return
}
print("Errore HTTP con codice \(code)")