Краткий ответ

При использовании lazy операции map и filter не выполняются сразу при создании цепочки. Они запускаются только во время обхода результата, поэтому можно избежать создания промежуточных коллекций и прекратить обработку после получения нужного количества элементов.

Это не означает автоматического кэширования: при повторном обходе вычисления обычно выполняются заново. Для обычного Sequence также важно учитывать, что он может быть одноразовым и не гарантировать повторный проход.

Исторический контекст

Обычные операции над коллекциями в Swift возвращают новый результат после полного выполнения операции. Последовательная цепочка таких вызовов может создавать промежуточные коллекции и обрабатывать элементы, которые в итоге не понадобятся.

Ленивые последовательности появились как способ отложить вычисления до момента фактического потребления результата. Такой подход снижает лишние аллокации и позволяет строить конвейеры обработки данных с ранним завершением.

Постановка проблемы

Предположим, приложение ищет первые несколько подходящих объектов среди большого набора данных. При обычной цепочке сначала могут быть полностью построены результаты map и filter, даже если нужен только первый найденный элемент.

Неверное понимание lazy приводит к двум типичным ошибкам: ожиданию немедленного выполнения преобразований и предположению, что уже вычисленные значения будут сохранены. В результате можно получить либо неожиданно поздний побочный эффект, либо повторно дорогую обработку при нескольких обходах.

Подробное решение

lazy меняет стратегию вычисления: вместо немедленного формирования результата создаётся объект-обёртка, хранящий исходную последовательность и правила преобразований. При запросе очередного элемента он получает элементы источника, применяет операции цепочки и выдаёт результат потребителю.

let numbers = Array(1...1_000_000)
let result = numbers.lazy
    .map { $0 * 2 }
    .filter { $0 % 3 == 0 }
    .prefix(2)

for value in result {
    print(value)
}

В этом примере вычисляются только элементы, необходимые для получения первых двух результатов. Для каждого кандидата операции выполняются по цепочке; полноценный промежуточный массив после map и после filter не создаётся.

Ленивость особенно полезна вместе с операциями, ограничивающими потребление: prefix, first, contains и некоторыми вариантами поиска. Она может уменьшить время и память, но не делает сами преобразования дешевле и не гарантирует выгоду, если результат нужно полностью пройти один раз.

Порядок операций сохраняет значение. Фильтрация до дорогого map может сократить число дорогих преобразований, если условие фильтрации доступно до преобразования. При этом ленивые цепочки не кэшируют результат по умолчанию: повторный обход снова обращается к источнику и повторяет вычисления.

Ситуация из практики

Сервис каталога должен найти первые десять товаров, удовлетворяющих условию, после нормализации данных. Исходный каталог содержит миллионы записей, а нормализация одного товара затратна.

Вариант с обычными коллекциями прост для чтения, но может создать несколько промежуточных массивов и обработать весь каталог до применения ограничения. Вариант с lazy уменьшает пиковое потребление памяти и останавливается после десяти результатов, однако повторное использование результата может повторить нормализацию.

Был выбран ленивый конвейер с ограничением результата на конце, потому что запрос почти всегда требовал небольшую страницу данных. Если бы результат использовался многократно, его стоило бы материализовать один раз в массив и затем переиспользовать.

Что кандидаты часто упускают

Кэширует ли lazy-цепочка уже вычисленные элементы?

Нет, сама ленивость не означает мемоизацию. При повторном обходе ленивой коллекции преобразования обычно выполняются снова; кроме того, результат зависит от поведения исходной коллекции и замыканий. Если вычисление дорогое или источник изменяемый, результат следует явно сохранить в материализованной коллекции, когда это соответствует требованиям приложения.

Всегда ли lazy быстрее обычной цепочки?

Нет. Если нужно полностью обработать небольшой набор данных, стоимость обёрток и вызовов замыканий может не дать преимущества, а иногда добавить небольшие накладные расходы. Выигрыш появляется главным образом при больших источниках, дорогих преобразованиях, раннем завершении или необходимости избежать промежуточных коллекций.

Можно ли безопасно повторно обойти любой lazy Sequence?

Нет. Протокол Sequence не требует многопроходности: конкретная последовательность может быть одноразовой. Даже если повторный обход технически возможен, он может заново вычислить элементы или зависеть от изменившегося источника, поэтому для гарантированного повторного доступа результат нужно материализовать в подходящую коллекцию.