Associated Values en Swift : ce que c'est, syntaxe et exemples

Que sont les Associated Values ?

Associated Values sont des informations supplémentaires qu'un cas d'enum peut stocker avec lui-même. Contrairement aux raw values, qui sont fixes au niveau de la déclaration, les associated values sont définies lors de la création d'une instance d'enum.

Imaginez la modélisation d'un moyen de paiement : le cas creditCard peut stocker les 4 derniers chiffres et la date d'expiration, tandis que le cas applePay ne stocke rien. Avec les associated values, cela s'implémente naturellement, sans sous-classes ni champs optionnels.

Selon la documentation Apple, les associated values transforment un enum d'un simple ensemble de constantes en un type de données algébrique (sum type), caractéristique des langages fonctionnels. Cela améliore considérablement l'expressivité du code.

Syntaxe des associated values

Les Associated Values sont déclarées entre parenthèses après le cas, en spécifiant les noms et types de paramètres, comme pour les fonctions.

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

Lors de la création d'une instance, les associated values sont passées comme arguments :

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

Swift n'impose pas de restrictions sur le nombre ou les types d'associated values. Vous pouvez utiliser des génériques, des fonctions de fermeture et d'autres enums à l'intérieur des associated values. Cela permet de construire des structures imbriquées complexes.

Les noms des paramètres d'associated values sont utilisés comme étiquettes d'arguments lors de la création d'une instance — cela améliore la lisibilité du code. Lors de l'extraction via switch, les noms servent de documentation, clarifiant la signification de chaque valeur. Cette approche rend le code auto-documenté et réduit la probabilité d'erreurs lors de la correspondance des données. C'est particulièrement précieux dans le développement en équipe de grandes applications iOS.

Switch avec associated values

Switch est le moyen principal d'extraire les associated values. Les valeurs sont liées à des constantes ou variables via let ou 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 prend en charge la correspondance partielle — vous pouvez spécifier des valeurs concrètes pour les associated values :

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

L'utilisation d'un joker (_) permet d'ignorer les associated values inutiles, et les constantes dans les cas permettent de vérifier la correspondance avec des valeurs spécifiques.

Associated Values vs Raw Values

De nombreux développeurs débutants confondent les associated values avec les raw values. Ce sont des mécanismes différents avec des cas d'utilisation différents.

Selon Swift Evolution, les associated values ont été introduites dans Swift 2.0 dans le cadre de la refonte des enums. Elles fournissent une approche algébrique des types, où chaque cas est un constructeur séparé avec sa propre signature.

Exemples pratiques d'associated values

Les Associated Values sont activement utilisées dans les projets iOS réels. Considérons trois scénarios typiques.

Modélisation des réponses API

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

Machine d'états UI

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

Avec les associated values, l'enum devient un outil puissant pour les machines d'état : chaque cas est un état, les associated values sont les paramètres de cet état. Le compilateur garantit que toutes les transitions sont traitées.

Extraction via if case et guard case

Pour vérifier un seul cas sans switch, utilisez if case ou guard case. C'est plus compact lorsque vous devez traiter une seule option.

let error = NetworkError.timeout(seconds: 30)

if case .timeout(let seconds) = error {
    print("Requête expirée après \(seconds)s")
}

guard case .httpError(let code, _) = error else {
    return
}
print("Erreur HTTP avec le code \(code)")