Enum in Swift — cos'è, sintassi e utilizzo

Cos'è enum in Swift?

Enum (enumerazione) è un tipo di dato personalizzato che unisce un insieme finito di varianti mutuamente esclusive. In Swift, enum non sono solo costanti numeriche, ma un tipo completo con la propria logica.

Ogni variante dell'enumerazione è chiamata caso. A differenza di Objective-C, dove enum si riduce a un tipo intero, Swift permette a ciascun caso di memorizzare i propri dati e avere metodi.

Secondo Apple, enum in Swift supporta generics, inizializzatori, proprietà calcolate e conformità ai protocolli — rendendolo applicabile per modellare stati, errori, opzioni e macchine a stati finiti.

Usa enum ovunque sia necessario rappresentare un insieme finito di varianti mutuamente esclusive: stati dello schermo, tipi di errore, direzioni, opzioni di filtraggio.

Sintassi di dichiarazione di enum

Enum viene dichiarato con la parola chiave enum seguita da un nome e un corpo tra parentesi graffe.

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

I casi possono essere dichiarati su una singola riga separati da virgola:

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

Per accedere a un caso, usa la sintassi punto dopo il tipo noto:

let direction = CompassDirection.north
// Tipo noto — sintassi abbreviata disponibile:
var currentPlanet = .earth

Una volta che a una variabile viene assegnato un tipo enum noto, Swift deduce automaticamente il tipo, consentendo di omettere il nome dell'enumerazione quando si accede ai casi.

Raw Values nelle enumerazioni

Raw Values sono valori di un singolo tipo assegnati a ciascun caso di enum. A differenza degli associated values, i raw values sono dello stesso tipo per tutti i casi e vengono definiti al momento della dichiarazione.

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

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

Per i raw values interi, Swift incrementa automaticamente i valori se solo il primo è impostato esplicitamente:

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

I raw values possono essere dei tipi Int, String, Character o qualsiasi tipo conforme al protocollo RawRepresentable. Swift genera automaticamente l'inizializzatore init? per creare un enum da un raw value — comodo per analizzare dati dalle API.

Associated Values in enum

Associated Values consentono di associare diversi tipi di dati a ciascun caso di enum individualmente. A differenza dei raw values, gli associated values possono differire per tipo e quantità.

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

Quando si elabora con switch, gli associated values vengono estratti tramite binding a variabili o costanti:

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

switch error {
case .timeout(let seconds):
    print("Timeout dopo \(seconds)s")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Nessuna connessione")
case .unknown(let err):
    print("Sconosciuto: \(err.localizedDescription)")
}

Secondo la documentazione Apple, gli associated values rendono enum uno strumento espressivo per modellare stati complessi senza creare tipi wrapper separati. Usali per scenari simili a Result e modellazione di errori con contesto.

Enum ricorsivo (indirect)

Enum ricorsivo — un'enumerazione i cui casi fanno riferimento al tipo enum stesso. Tali casi vengono contrassegnati con la parola chiave indirect.

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

Usare indirect prima di enum contrassegna tutti i casi come ricorsivi. In alternativa, è possibile contrassegnare solo un caso specifico con indirect:

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

Swift usa indirect per memorizzare i casi ricorsivi come riferimenti (semantica di riferimento) invece che come valori — questo evita la dimensione infinita dell'enum sullo stack. Gli enum ricorsivi sono ampiamente utilizzati nella costruzione di alberi, liste collegate e AST.

Enum e protocolli

Enum può essere conforme ai protocolli proprio come strutture e classi. Questa è una caratteristica fondamentale della programmazione orientata ai protocolli 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 può anche essere conforme ai protocolli Cocoa — ad esempio, CaseIterable per la generazione automatica di una raccolta di tutti i casi, o Codable per la serializzazione. Questo rende enum un elemento costruttivo versatile nelle applicazioni Swift.