Réponse.

Typealias est un mécanisme permettant de créer des alias pour des types existants, ce qui facilite la lecture du code, améliore le support des projets et permet de réutiliser des abstractions.

Historique de la question

Le typealias est apparu comme un héritage de nombreux autres langages, par exemple, le typedef en C. En Swift, le typealias est intégré au système de types et est largement utilisé pour les types génériques et les protocoles avec un type associé.

Problème

Dans de grands projets, on rencontre souvent de longs types génériques, des types composés, des compositions et des types imbriqués. Sans alias, ces constructions deviennent illisibles et compliquent le support de l'application.

Solution

Déclarer un typealias pour des types fréquemment utilisés ou complexes rend le code plus simple, plus compréhensible et mieux structuré. De plus, le typealias est souvent utilisé pour définir des alias pour les protocoles avec des associatedtype, afin de contourner les limitations des protocoles en tant que types.

Exemple de code :

typealias JSON = [String: Any]
typealias CompletionHandler = (Result<Int, Error>) -> Void

typealias StringDictionary = Dictionary<String, String>
typealias Handler = (String) -> Void

Caractéristiques clés :

Amélioration de la lisibilité et du support du code
Simplification du travail avec des types génériques
Permet de cacher les détails d'implémentation des types

Questions pièges.

Peut-on créer un nouveau type avec typealias ?

Non, le typealias ne crée pas un nouveau type — c'est simplement un alias, un synonyme complet d'un type existant, et le compilateur les considère comme le même type.

typealias Age = Int
let a: Age = 25
let b: Int = a // Tout est correct

Le typealias fonctionnera-t-il au niveau de la sécurité des types ?

Non, le typealias ne protège pas contre le passage d'un type incorrect : JSON et [String: Any] sont interchangeables. Pour contrôler ou séparer la logique, il faut utiliser des structures/vérificateurs séparés, et non un typealias.

typealias UserID = Int
typealias ProductID = Int
func logId(_ id: UserID) {}
let productId: ProductID = 42
logId(productId) // Le compilateur ne génère pas d'erreur !

Peut-on déclarer un typealias à l'intérieur de protocoles ou de types génériques ?

Oui, à l'intérieur des protocoles, on déclare souvent des associatedtype ou des typealias, en particulier pour des types génériques complexes ou des interfaces personnalisées.

protocol DataSource {
    associatedtype Item
    typealias CompletionBlock = (Item) -> Void
}

Erreurs typiques et anti-paternes

Utiliser typealias au lieu d'un wrapper autour du type, lorsque vous avez besoin d'une sémantique de types distincts
Déclarer des typealias avec des noms peu clairs, ce qui nuit à la lisibilité
Utilisation excessive de typealias, ce qui entraîne confusion et complexité dans le refactoring des types

Exemple de la vie réelle

Cas négatif

Tous les identifiants de modèles sont déclarés via typealias comme Int :

typealias UserID = Int
typealias ProductID = Int

func deleteUser(id: UserID)
func deleteProduct(id: ProductID)

Avantages :

Pratique à écrire Inconvénients :
Erreurs : facile de confondre les identifiants, le compilateur ne protègera pas contre le passage d'un id incorrect

Cas positif

Pour un type générique complexe ou un résultat de type closure, on déclare un typealias :

typealias Completion<T> = (Result<T, Error>) -> Void
let completion: Completion<String>