Enum in Swift — wat is het, syntaxis en gebruik

Wat is enum in Swift?

Enum (enumeratie) — een door de gebruiker gedefinieerd gegevenstype dat een eindige verzameling elkaar uitsluitende varianten verenigt. In Swift is enum niet alleen numerieke constanten, maar een volwaardig type met eigen logica.

Elke variant van de enumeratie wordt een case genoemd. In tegenstelling tot Objective-C, waar enum wordt gereduceerd tot een geheel getal type, staat Swift elke case toe om eigen gegevens op te slaan en methoden te hebben.

Volgens Apple ondersteunt enum in Swift generics, initializers, berekende eigenschappen en implementatie van protocollen — dit maakt het toepasbaar voor het modelleren van toestanden, fouten, opties en eindige automaten.

Gebruik enum overal waar een eindige verzameling elkaar uitsluitende varianten moet worden weergegeven: schermtoestanden, fouttypen, richtingen, filteropties.

Syntaxis van enum-declaratie

Enum wordt gedeclareerd met het sleutelwoord enum gevolgd door een naam en een lichaam in accolades.

enum CompassDirection {
    case north
    case south
    case east
    case west
}

Cases kunnen op één regel worden gedeclareerd met een komma:

enum Planet {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}

Om een case te benaderen wordt puntnotatie gebruikt na het bekende type:

let direction = CompassDirection.north
// Type is bekend — verkorte syntaxis is beschikbaar:
var currentPlanet = .earth

Na toewijzing aan een variabele van een bekend enum-type leidt Swift automatisch het type af en kan de naam van de enumeratie worden weggelaten bij het benaderen van cases.

Raw Values in enumeraties

Raw Values — waarden van hetzelfde type die aan elke case van de enum worden toegewezen. In tegenstelling tot associated values zijn raw values qua type identiek voor alle cases en worden ze bij declaratie ingesteld.

enum HTTPStatusCode: Int {
    case ok = 200
    case notFound = 404
    case internalServerError = 500
}

let code = HTTPStatusCode.notFound
print(code.rawValue) // 404

Voor gehele raw values verhoogt Swift automatisch de waarden als alleen de eerste expliciet is opgegeven:

enum Status: Int {
    case pending = 1
    case active      // 2
    case completed   // 3
}

Raw values kunnen van het type Int, String, Character of elk type zijn dat voldoet aan het protocol RawRepresentable. Swift genereert automatisch de initializer init? om een enum uit een raw value te maken — handig bij het parsen van API-gegevens.

Associated Values in enum

Associated Values maken het mogelijk om verschillende gegevenstypen aan elke case van de enumeratie afzonderlijk te koppelen. In tegenstelling tot raw values kunnen associated values verschillen in type en hoeveelheid.

enum NetworkError {
    case timeout(seconds: Int)
    case httpError(code: Int, message: String)
    case noConnection
    case unknown(error: Error)
}

Bij verwerking via switch worden associated values geëxtraheerd door binding aan variabelen of constanten:

let error = NetworkError.httpError(code: 403, message: "Forbidden")

switch error {
case .timeout(let seconds):
    print("Time-out na \(seconds)s")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Geen verbinding")
case .unknown(let err):
    print("Onbekend: \(err.localizedDescription)")
}

Volgens Apple-documentatie maken associated values van enum een expressief hulpmiddel voor het modelleren van complexe toestanden zonder aparte wrapper-typen te creëren. Gebruik ze voor Result-achtige scenario's en het modelleren van fouten met context.

Recursieve enum (indirect)

Recursieve enum — een enumeratie waarvan de cases verwijzen naar het enum-type zelf. Dergelijke cases worden gemarkeerd met het sleutelwoord indirect.

indirect enum LinkedList<T> {
    case empty
    case node(value: T, next: LinkedList<T>)
}

Het sleutelwoord indirect voor enum markeert alle cases als recursief. Als alternatief kan alleen een specifieke case worden gemarkeerd met indirect:

enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}

Swift gebruikt indirect om recursieve cases als referenties (reference semantics) op te slaan in plaats van waarden — dit voorkomt een oneindige grootte van de enum op de stack. Recursieve enum worden veel gebruikt bij het bouwen van bomen, gelinkte lijsten en AST.

Enum en protocollen

Enum kan protocollen implementeren net zoals structuren en klassen. Dit is een belangrijke mogelijkheid van protocol-georiënteerd programmeren in Swift.

protocol Describable {
    var description: String { get }
}

enum PaymentMethod: Describable {
    case creditCard(last4: String)
    case applePay
    case bankTransfer

    var description: String {
        switch self {
        case .creditCard(let last4):
            return "Card ending in \(last4)"
        case .applePay:
            return "Apple Pay"
        case .bankTransfer:
            return "Bank Transfer"
        }
    }
}

Enum kan ook Cocoa-protocollen implementeren — bijvoorbeeld CaseIterable voor het automatisch genereren van een verzameling van alle cases of Codable voor serialisatie. Dit maakt enum een universele bouwsteen in Swift-applicaties.