Associated Values en Swift: qué es, sintaxis y ejemplos

¿Qué son los Associated Values?

Associated Values son información adicional que un caso de enum puede almacenar consigo mismo. A diferencia de los raw values, que son fijos en el nivel de declaración, los associated values se establecen al crear una instancia de enum.

Imagina modelar un método de pago: el caso creditCard puede almacenar los últimos 4 dígitos y la fecha de vencimiento, mientras que el caso applePay no almacena nada. Con associated values, esto se implementa de forma natural, sin subclases ni campos opcionales.

Según la documentación de Apple, los associated values convierten un enum de un simple conjunto de constantes en un tipo de datos algebraico (sum type), característico de los lenguajes funcionales. Esto mejora significativamente la expresividad del código.

Sintaxis de associated values

Los Associated Values se declaran entre paréntesis después del caso, especificando nombres y tipos de parámetros, como en las funciones.

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

Al crear una instancia, los associated values se pasan como argumentos:

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

Swift no impone restricciones sobre la cantidad o los tipos de associated values. Puedes usar genéricos, funciones de cierre y otros enum dentro de associated values. Esto permite construir estructuras anidadas complejas.

Los nombres de los parámetros de associated values se utilizan como etiquetas de argumento al crear una instancia — esto mejora la legibilidad del código. Al extraerlos mediante switch, los nombres sirven como documentación, aclarando el significado de cada valor. Este enfoque hace que el código sea autodocumentado y reduce la probabilidad de errores al coincidir datos. Esto es especialmente valioso en el desarrollo en equipo de grandes aplicaciones iOS.

Switch con associated values

Switch es la forma principal de extraer associated values. Los valores se vinculan a constantes o variables mediante let o 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 admite coincidencia parcial — se pueden especificar valores concretos para associated values:

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

Usar un comodín (_) permite ignorar associated values innecesarios, y las constantes en los casos permiten verificar coincidencias con valores específicos.

Associated Values vs Raw Values

Muchos desarrolladores principiantes confunden los associated values con los raw values. Son mecanismos diferentes con diferentes casos de uso.

Según Swift Evolution, los associated values se introdujeron en Swift 2.0 como parte del rediseño de enum. Proporcionan un enfoque algebraico a los tipos, donde cada caso es un constructor separado con su propia firma.

Ejemplos prácticos de associated values

Los Associated Values se utilizan activamente en proyectos iOS reales. Consideremos tres escenarios típicos.

Modelado de respuestas de API

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

Máquina de Estados de UI

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

Con associated values, enum se convierte en una herramienta poderosa para máquinas de estado: cada caso es un estado, los associated values son parámetros de ese estado. El compilador garantiza que todas las transiciones sean manejadas.

Extracción mediante if case y guard case

Para verificar un solo caso sin switch, usa if case o guard case. Esto es más compacto cuando solo necesitas manejar una opción.

let error = NetworkError.timeout(seconds: 30)

if case .timeout(let seconds) = error {
    print("Solicitud agotada después de \(seconds)s")
}

guard case .httpError(let code, _) = error else {
    return
}
print("Error HTTP con código \(code)")