Associated Values in Swift: wat is het, syntax en voorbeelden

Wat zijn Associated Values?

Associated Values — zijn extra informatie die een enum case samen met zichzelf kan opslaan. In tegenstelling tot raw values, die op declaratieniveau zijn vastgelegd, worden associated values bepaald bij het maken van een enum-instantie.

Stel je het modelleren van een betaalmethode voor: case creditCard kan de laatste 4 cijfers en de vervaldatum opslaan, en case applePay — niets. Met associated values wordt dit op een natuurlijke manier geïmplementeerd, zonder subklassen of optionele velden.

Volgens de Apple-documentatie transformeren associated values enum van een eenvoudige set constanten naar een algebraïsch gegevenstype (sum type), kenmerkend voor functionele talen. Dit verhoogt de expressiviteit van de code aanzienlijk.

Syntax van associated values

Associated values worden gedeclareerd tussen ronde haakjes na de case, met vermelding van parameternamen en -typen, zoals bij functies.

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

Bij het maken van een instantie worden associated values doorgegeven als argumenten:

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

Swift legt geen beperkingen op aan het aantal of de typen associated values. Je kunt generics, closure-functies en andere enum gebruiken binnen associated values. Dit maakt het mogelijk om complexe geneste structuren te bouwen.

De parameternamen van associated values worden gebruikt als argumentlabels bij het maken van een instantie — dit verbetert de leesbaarheid van de code. Bij extractie via switch dienen de namen als documentatie en verduidelijken ze de betekenis van elke waarde. Een dergelijke aanpak maakt code zelfdocumenterend en vermindert de kans op fouten bij het matchen van gegevens. Dit is vooral waardevol bij teamontwikkeling van grote iOS-applicaties.

Switch met associated values

Switch — de belangrijkste manier om associated values te extraheren. Waarden worden gebonden aan constanten of variabelen via let of 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 ondersteunt gedeeltelijke matching — specifieke waarden van associated values kunnen worden opgegeven:

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

Het gebruik van wildcard (_) maakt het mogelijk om onnodige associated values te negeren, en constanten in cases — om overeenkomst met specifieke waarden te controleren.

Associated Values vs Raw Values

Veel beginnende ontwikkelaars verwarren associated values met raw values. Dit zijn verschillende mechanismen met verschillende toepassingsscenario's.

Volgens Swift Evolution zijn associated values geïntroduceerd in Swift 2.0 als onderdeel van het herontwerp van enum. Ze bieden een algebraïsche benadering van typen, waarbij elke case een aparte constructor is met een eigen handtekening.

Praktische voorbeelden van associated values

Associated values worden actief gebruikt in echte iOS-projecten. Laten we drie typische scenario's bekijken.

Modelleren van API-antwoorden

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

UI State Machine

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

Met associated values wordt enum een krachtig hulpmiddel voor eindige automaten: elke case is een toestand, associated values — de parameters van die toestand. De compiler garandeert dat alle overgangen worden afgehandeld.

Extractie via if case en guard case

Gebruik voor het controleren van één case zonder switch if case of guard case. Dit is compacter wanneer slechts één variant moet worden verwerkt.

let error = NetworkError.timeout(seconds: 30)

if case .timeout(let seconds) = error {
    print("Verzoek verlopen na \(seconds)s")
}

guard case .httpError(let code, _) = error else {
    return
}
print("HTTP-fout met code \(code)")