¿Qué es una secuencia perezosa (lazy sequence) en Swift? ¿Cómo funciona, cuándo debería usarse y cuáles son las trampas?

Respuesta.

Una lazy sequence es un envoltorio especial alrededor de una colección que permite diferir la ejecución de cálculos (filter, map, etc.) hasta el momento de acceso a los elementos. Esto significa que las operaciones en la lazy sequence se calcularán solo cuando se acceda a sus resultados (por ejemplo, al llamar a .forEach, .first, convirtiéndolo en un array, etc.).

Cuándo usar:

• Al trabajar con secuencias grandes, si no es necesario procesar todos los elementos de inmediato.
• Cuando queremos evitar asignaciones intermedias durante transformaciones secuenciales (map -> filter -> ...).

Ejemplo:

let numbers = Array(1...1_000_000)
let lazyNumbers = numbers.lazy.map { $0 * 2 }.filter { $0 % 3 == 0 }
let first = lazyNumbers.first // ¡La cadena de operaciones se calculará sólo ahora para el primer elemento adecuado!

Trampas:

• Los cálculos se realizan de nuevo cada vez que se recorre la .lazy sequence.
• Dependen del orden de llamada: si es necesario recorrer los datos varias veces con diferentes condiciones, los datos se recalcularán.
• Las acciones diferidas pueden ser fuente de efectos secundarios inesperados, si hay efectos secundarios en los closures anidados.

Pregunta engañosa.

¿Cuál es la diferencia entre llamar a .map { ... } y .lazy.map { ... } en un array?

Respuesta:

• .map { ... } aplica el closure a cada elemento y devuelve un nuevo array de inmediato, es decir, todos los elementos serán procesados y guardados en memoria.
• .lazy.map { ... } no devuelve un array, sino una lazy-sequence (envoltura) que no realiza el procesamiento de los elementos de inmediato, sino solo al acceder a ellos.

Ejemplo:

let a = Array(1...10)
let eagers = a.map { $0 * 2 }        // Array con 10 elementos
let laziers = a.lazy.map { $0 * 2 } // LazySequence, que no contiene resultados de inmediato

Ejemplos de errores reales debido al desconocimiento de los matices del tema.

---

Historia

En un gran proyecto, un desarrollador aplicó una cadena de múltiples llamadas a map, filter, reduce a un enorme array de datos sin .lazy. Esto llevó a la asignación temporal de grandes arrays en cada paso intermedio, duplicando el consumo de memoria y provocando bloqueos en algunos dispositivos con poca RAM.

---

Historia

En un bloque de código se utilizó una lazy sequence con un efecto secundario en el closure interno (por ejemplo, enviar un evento o imprimir dentro de map/filter). El desarrollador esperaba que esta operación se ejecutara inmediatamente, sin embargo, el evento no ocurrió en absoluto, porque nunca se accedió a los elementos de la lazy sequence, y el código con el evento no se ejecutó. Como resultado, los registros y métricas eran incorrectos.

---

Historia

En el caso de recopilar estadísticas de un gran conjunto de datos, se utilizó lazy sequence en combinación con múltiples recorridos (por ejemplo, se buscaba primero dos veces y luego se contaba). Cada recorrido por la lazy sequence iniciaba un recálculo completo de las operaciones, lo que llevó a una desaceleración y carga innecesaria en el sistema. Tras sustituirlo por un array normal, el problema desapareció.