Réponse.

Les collections paresseuses (Lazy Collections) sont un mécanisme particulier introduit dans Swift 2, qui permet de retarder les calculs sur les collections jusqu'au moment où l'on accède réellement au résultat. Au départ, les méthodes standards des collections (par exemple, map, filter) renvoyaient un résultat entièrement calculé d'une nouvelle collection, ce qui pouvait parfois entraîner des coûts inutiles en mémoire et en temps, notamment lors de la manipulation de grands tableaux ou de chaînes de transformations.

Problème : cela conduit à la création excessive de collection intermédiaires. Chaque appel à map ou filter crée une nouvelle copie des données, ce qui peut considérablement ralentir les performances du programme lors d'opérations multiples.

Solution : utiliser des collections paresseuses via la propriété .lazy. Swift regroupe toutes les opérations en une seule chaîne et ne calcule que les éléments auxquels on accède réellement.

Exemple de code :

let array = Array(1...1_000_000)
let result = array.lazy.filter { $0 % 2 == 0 }.map { $0 * 3 }
print(result.prefix(5)) // Seules les 5 premières valeurs seront calculées

Caractéristiques clés :

Les calculs ne s'effectuent qu'au moment de l'accès à l'élément (à la demande).
Aucune collection intermédiaire n'est créée lors des chaînes de map/filter.
Cela permet d'économiser de la mémoire et du temps pour de grandes quantités de données.

Questions pièges.

Question 1 : let b = a.lazy.map { ... } renvoie-t-il immédiatement le résultat du calcul ?

Non, lorsque vous utilisez .lazy et les méthodes map/filter, le résultat du calcul n'est retourné qu'au moment de l'accès direct aux données (par exemple, via for-in, first, reduce).

Exemple de code :

let array = [1, 2, 3]
let mapped = array.lazy.map { x in
    print("traitement\(x)")
    return x * 2
}
// À ce stade, rien ne sera affiché
let first = mapped.first // C'est ici que les calculs commencent et que le résultat apparaît

Question 2 : Peut-on ajouter un nouvel élément à la collection d'origine après .lazy et sera-t-il également traité si l'on accède au résultat plus tard ?

Non, la collection paresseuse reflète l'état de la collection au moment de la création de la représentation paresseuse. Les éléments ajoutés ultérieurement ne seront pas pris en compte.

Question 3 : L'utilisation de .lazy est-elle efficace pour de petites collections (<100 éléments) ?

Non, pour les petites collections, le gain des calculs paresseux est pratiquement imperceptible et, parfois, un surcoût supplémentaire a un impact négatif sur la performance.

Erreurs typiques et anti-patterns

Oublier d'accéder au résultat de la chaîne paresseuse et penser que les données sont déjà calculées.
Utiliser .lazy sur de petits tableaux, compliquant ainsi le code sans obtenir de gains de performance.
Modifier la collection d'origine après la création de la représentation paresseuse et s'attendre à ce que les modifications soient prises en compte.

Exemple de la vie réelle

Cas négatif

Dans le projet, .lazy a été utilisé à tort pour toutes les map/filter même sur de petites collections.

Avantages :

Uniformisation du style de code.

Inconvénients :

La performance a diminué à cause de la création constante de wrappers paresseux.
Des bugs sont apparus : les calculs n'étaient pas effectués et les données n'étaient pas traitées à temps.

Cas positif

Nous avons refactorisé des rapports sur une grande base de transactions en utilisant .lazy uniquement pour les fonctions où il y avait réellement de longues chaînes de transformations.