Enum en Swift — qué es, sintaxis y uso

¿Qué es enum en Swift?

Enum (enumeración) es un tipo de datos personalizado que une un conjunto finito de variantes mutuamente excluyentes. En Swift, enum no son solo constantes numéricas, sino un tipo completo con su propia lógica.

Cada variante de la enumeración se llama caso. A diferencia de Objective-C, donde enum se reduce a un tipo entero, Swift permite que cada caso almacene sus propios datos y tenga métodos.

Según Apple, enum en Swift admite genéricos, inicializadores, propiedades computadas y conformidad con protocolos, lo que lo hace aplicable para modelar estados, errores, opciones y máquinas de estados finitos.

Use enum siempre que necesite representar un conjunto finito de variantes mutuamente excluyentes: estados de pantalla, tipos de error, direcciones, opciones de filtrado.

Sintaxis de declaración de enum

Enum se declara con la palabra clave enum seguida de un nombre y un cuerpo entre llaves.

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

Los casos se pueden declarar en una sola línea separados por una coma:

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

Para acceder a un caso, use la sintaxis de punto después del tipo conocido:

let direction = CompassDirection.north
// El tipo es conocido: sintaxis abreviada disponible:
var currentPlanet = .earth

Una vez que a una variable se le asigna un tipo enum conocido, Swift infiere automáticamente el tipo, permitiendo omitir el nombre de la enumeración al acceder a los casos.

Raw Values en enumeraciones

Raw Values son valores de un solo tipo asignados a cada caso de enum. A diferencia de los associated values, los raw values son del mismo tipo para todos los casos y se definen en el momento de la declaración.

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

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

Para raw values enteros, Swift incrementa automáticamente los valores si solo el primero se establece explícitamente:

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

Los raw values pueden ser de tipos Int, String, Character o cualquier tipo que conforme al protocolo RawRepresentable. Swift genera automáticamente el inicializador init? para crear un enum a partir de un raw value, conveniente para analizar datos de APIs.

Associated Values en enum

Associated Values permiten vincular diferentes tipos de datos a cada caso de enum individualmente. A diferencia de los raw values, los associated values pueden diferir en tipo y cantidad.

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

Al procesar con switch, los associated values se extraen mediante la vinculación a variables o constantes:

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

switch error {
case .timeout(let seconds):
    print("Tiempo de espera agotado tras \(seconds)s")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Sin conexión")
case .unknown(let err):
    print("Desconocido: \(err.localizedDescription)")
}

Según la documentación de Apple, los associated values hacen de enum una herramienta expresiva para modelar estados complejos sin crear tipos contenedores separados. Úselos para escenarios tipo Result y modelado de errores con contexto.

Enum recursivo (indirect)

Enum recursivo — una enumeración cuyos casos hacen referencia al propio tipo enum. Dichos casos se marcan con la palabra clave indirect.

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

Usar indirect antes de enum marca todos los casos como recursivos. Alternativamente, puede marcar solo un caso específico con indirect:

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

Swift usa indirect para almacenar casos recursivos como referencias (semántica de referencia) en lugar de valores, lo que evita un tamaño infinito de enum en la pila. Los enum recursivos se usan ampliamente en la construcción de árboles, listas enlazadas y AST.

Enum y protocolos

Enum puede conformar protocolos igual que las estructuras y las clases. Esta es una característica clave de la programación orientada a protocolos en 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 también puede conformar protocolos de Cocoa, por ejemplo, CaseIterable para la generación automática de una colección de todos los casos, o Codable para serialización. Esto hace de enum un bloque de construcción versátil en aplicaciones Swift.