Associated Values în Swift: ce este, sintaxă și exemple

Ce sunt Associated Values?

Associated Values — sunt informații suplimentare pe care un case enum le poate stoca împreună cu sine. Spre deosebire de raw values, care sunt fixate la nivelul declarației, associated values sunt stabilite la crearea instanței enum.

Imaginați-vă modelarea unei metode de plată: case-ul creditCard poate stoca ultimele 4 cifre și data expirării, iar case-ul applePay — nimic. Cu associated values acest lucru se implementează natural, fără subclase sau câmpuri opționale.

Conform documentației Apple, associated values transformă enum dintr-un set simplu de constante într-un tip de date algebric (sum type), caracteristic limbajelor funcționale. Acest lucru crește semnificativ expresivitatea codului.

Sintaxa associated values

Associated values sunt declarate în paranteze rotunde după case, cu indicarea numelor și tipurilor parametrilor, ca la funcții.

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

La crearea instanței, associated values sunt transmise ca argumente:

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

Swift nu impune restricții asupra numărului sau tipurilor de associated values. Puteți folosi generice, funcții closure și alte enum-uri în interiorul associated values. Acest lucru face posibilă construirea de structuri imbricate complexe.

Numele parametrilor associated values sunt folosite ca etichete de argumente la crearea instanței — acest lucru îmbunătățește lizibilitatea codului. La extragerea prin switch, numele servesc ca documentație, explicând semnificația fiecărei valori. O astfel de abordare face codul autodocumentat și reduce probabilitatea erorilor la potrivirea datelor. Acest lucru este deosebit de valoros în dezvoltarea în echipă a aplicațiilor iOS mari.

Switch cu associated values

Switch — modul principal de extragere a associated values. Valorile sunt legate la constante sau variabile prin let sau 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 suportă potrivirea parțială — se pot specifica valori concrete ale associated values:

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

Utilizarea wildcard (_) permite ignorarea associated values inutile, iar constantele în case-uri — verificarea coincidenței cu valori specifice.

Associated Values vs Raw Values

Mulți dezvoltatori începători confundă associated values cu raw values. Sunt mecanisme diferite cu scenarii de aplicare diferite.

Conform Swift Evolution, associated values au fost introduse în Swift 2.0 ca parte a reproiectării enum. Ele asigură o abordare algebrică a tipurilor, unde fiecare case este un constructor separat cu propria semnătură.

Exemple practice de associated values

Associated values sunt utilizate activ în proiecte iOS reale. Să examinăm trei scenarii tipice.

Modelarea răspunsurilor API

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

Mașina de stări UI

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

Cu associated values, enum devine un instrument puternic pentru mașini cu stări finite: fiecare case — o stare, associated values — parametrii acelei stări. Compilatorul garantează că toate tranzițiile sunt procesate.

Extragerea prin if case și guard case

Pentru verificarea unui singur case fără switch utilizați if case sau guard case. Este mai compact când trebuie procesată doar o variantă.

let error = NetworkError.timeout(seconds: 30)

if case .timeout(let seconds) = error {
    print("Cererea a expirat după \(seconds)s")
}

guard case .httpError(let code, _) = error else {
    return
}
print("Eroare HTTP cu codul \(code)")