Enumeraciones en Swift: raw values, associated values y pattern matching

8 de julio de 2026Por Angel Carrero1 min de lectura
Enumeraciones en Swift: raw values, associated values y pattern matching

Las enumeraciones de Swift son tipos completos que pueden tener métodos, propiedades computadas, raw values y associated values. No se limitan a enteros como en C; son tan expresivas que el propio tipo Optional de Swift es, bajo el capó, un enum.

Enums básicos y raw values

enum Direccion: String, CaseIterable {
    case norte = "N"
    case sur   = "S"
    case este  = "E"
    case oeste = "O"
}

let dir = Direccion.norte
print(dir.rawValue)  // N

let desde = Direccion(rawValue: "S")
print(desde!)  // sur

print(Direccion.allCases.map(.rawValue))
// ["N", "S", "E", "O"]

Associated values

Un caso puede llevar datos de cualquier tipo, distintos por caso:

enum Resultado {
    case exito(valor: Int)
    case fallo(mensaje: String)
    case pendiente
}

let r = Resultado.exito(valor: 42)
switch r {
case .exito(let v):   print("OK: (v)")
case .fallo(let m):   print("Error: (m)")
case .pendiente:      print("Esperando")
}
// OK: 42

Métodos en enums

enum Planeta: Int {
    case mercurio=1, venus, tierra, marte

    var esHabitable: Bool { self == .tierra }

    func descripcion() -> String {
        "Planeta (rawValue): (self)"
    }
}

print(Planeta.tierra.esHabitable)       // true
print(Planeta.marte.descripcion())      // Planeta 4: marte

Enums indirectos (recursivos)

indirect enum Expresion {
    case numero(Int)
    case suma(Expresion, Expresion)
    case producto(Expresion, Expresion)
}

func evaluar(_ e: Expresion) -> Int {
    switch e {
    case .numero(let n):         return n
    case .suma(let a, let b):    return evaluar(a) + evaluar(b)
    case .producto(let a, let b): return evaluar(a) * evaluar(b)
    }
}

let expr = Expresion.suma(.numero(3), .producto(.numero(4), .numero(5)))
print(evaluar(expr))  // 23

Sigue leyendo