# Swift Lazy Collections Explained with map, filter, and Performance Source: https://devdocs10.com/articles/swift/swift-lazy-collections By Murat Bo · Updated 2026-10-17 · DevDocs10 (https://devdocs10.com) Swift lazy collections let you delay work until values are actually needed. This matters when you are chaining operations like `map`, `filter`, and `prefix` on large collections, because a lazy pipeline can avoid creating unnecessary intermediate arrays and can stop early when enough results have been produced. In this article, you will learn what lazy collections are, how they work in Swift 5+, when they help performance, and where they can confuse beginners. > **Quick answer:** In Swift, adding `lazy` to a sequence or collection creates a lazy view that postpones transformations until elements are requested. This often improves efficiency for chained operations, but it does not always make code faster, and it can change when work happens. > **Difficulty:** Intermediate > > **Helpful to know first:** You will understand this better if you already know basic Swift arrays, closures, and common sequence methods like `map`, `filter`, and `reduce`. ## 1. What Is Lazy Collections? A lazy collection in Swift is a wrapper around an existing sequence or collection that delays computation. Instead of immediately producing a new array for each operation, Swift stores the operations and performs them only when elements are accessed. - `lazy` creates a lazy view, not a brand-new fully computed collection. - Transformations such as `map` and `filter` happen on demand. - Lazy pipelines can avoid building intermediate arrays. - Lazy evaluation is especially useful when you only need part of the result, such as the first few matching items. - Lazy collections are different from Swift's `lazy` stored properties. A lazy property delays property initialization, while a lazy collection delays sequence processing. Without laziness, this code computes everything immediately: ```swift let numbers = Array(1...10) let result = numbers .filter { $0 % 2 == 0 } .map { $0 * 10 } ``` This creates intermediate results as each step finishes. With laziness, the work is deferred: ```swift let numbers = Array(1...10) let result = numbers .lazy .filter { $0 % 2 == 0 } .map { $0 * 10 } ``` In this version, Swift postpones the filtering and mapping until you actually iterate over `result` or convert it into a concrete type like `Array`. ## 2. Why Lazy Collections Matters Lazy collections matter because eager processing can do more work than you need. If you filter one million items, map them, and then only take the first five, eager code may process the entire input first. Lazy code can stop as soon as five valid results are found. That makes lazy pipelines useful when: - you are working with large arrays or ranges - you are chaining several transformations - you only need some of the final values - the transformation work is expensive - you want to reduce temporary memory usage Lazy collections do *not* automatically make every program faster. If you eventually consume every element anyway, the performance difference may be small, and sometimes the added abstraction is not worth the complexity. ## 3. Basic Syntax The basic syntax is simple: access `lazy` on a sequence or collection, then chain operations. ### Creating a lazy pipeline Here is the minimal pattern: ```swift let values = [1, 2, 3, 4, 5] let lazyValues = values.lazy .map { $0 * 2 } ``` This does not immediately create a doubled array. It creates a lazy mapped view. ### Forcing evaluation To get a real array, convert the result: ```swift let arrayResult = Array(lazyValues) print(arrayResult) ``` At that point, Swift evaluates the pipeline and stores the output in an array. ### Understanding lazy vs eager This example shows when work happens: ```swift let numbers = [1, 2, 3] let lazyResult = numbers.lazy.map { print("Mapping \($0)") return $0 * 2 } print("Before iteration") for value in lazyResult { print(value) } ``` Output (tested with Swift 6.4): ```text Before iteration Mapping 1 2 Mapping 2 4 Mapping 3 6 ``` You will see `"Before iteration"` first, then the mapping messages during iteration. That proves the transformation is deferred. ## 4. Step-by-Step Examples ### Example 1: Lazy map on a range This example shows a simple lazy mapping operation on a range. ```swift let doubled = (1...5).lazy.map { $0 * 2 } for item in doubled { print(item) } ``` Output (tested with Swift 6.4): ```text 2 4 6 8 10 ``` Swift computes each doubled value as the loop requests it. It does not build the complete output array first. ### Example 2: Chaining filter and map Lazy collections are most useful when multiple operations are chained. ```swift let scores = [45, 82, 91, 33, 76] let passedLabels = scores.lazy .filter { $0 >= 50 } .map { "Pass: \($0)" } print(Array(passedLabels)) ``` Output (tested with Swift 6.4): ```text ["Pass: 82", "Pass: 91", "Pass: 76"] ``` The filter and map are both delayed until the array conversion happens. ### Example 3: Stopping early with prefix This is one of the best use cases for laziness. The pipeline can stop as soon as enough values are found. ```swift let result = (1...1_000_000).lazy .filter { $0 % 3 == 0 } .map { $0 * 10 } .prefix(5) print(Array(result)) ``` Output (tested with Swift 6.4): ```text [30, 60, 90, 120, 150] ``` Here Swift does not need to process all one million numbers. It only works until it has produced five matching results. ### Example 4: Seeing evaluation happen on demand Printing inside the closures makes it clear that values are generated one by one. ```swift let names = ["anna", "ben", "carla"] let lazyUppercased = names.lazy.map { print("Transforming \($0)") return $0.uppercased() } print("Only first value:") print(lazyUppercased.first ?? "none") ``` Output (tested with Swift 6.4): ```text Only first value: Transforming anna ANNA ``` Only the first element needs to be transformed because only `first` is requested. ## 5. Practical Use Cases - Processing large log entries and taking only the first few matches. - Searching a big data set with `filter` followed by `prefix`. - Transforming ranges, such as generating calculated numeric values on demand. - Avoiding intermediate arrays in pipelines with multiple `map` and `filter` steps. - Working with expensive transformations where computing every element up front would waste time. - Building readable pipelines that are only materialized at the final step. ## 6. Common Mistakes ### Mistake 1: Expecting lazy code to run immediately Beginners often assume the closure inside a lazy pipeline runs at the moment the pipeline is defined. It does not. The work happens later, when values are requested. **Problem:** This code expects the print statements inside `map` to run immediately, but the lazy sequence has not been consumed yet. ```swift let numbers = [1, 2, 3] let lazyResult = numbers.lazy.map { print("Mapping \($0)") return $0 * 2 } print("Done") ``` Output (tested with Swift 6.4): ```text Done ``` **Fix:** Iterate over the lazy result or convert it to an array when you actually want the work to happen. ```swift let numbers = [1, 2, 3] let lazyResult = numbers.lazy.map { print("Mapping \($0)") return $0 * 2 } print(Array(lazyResult)) ``` Output (tested with Swift 6.4): ```text Mapping 1 Mapping 2 Mapping 3 [2, 4, 6] ``` The corrected version works because converting to `Array` forces evaluation of the lazy pipeline. ### Mistake 2: Assuming lazy always means faster Lazy evaluation can reduce unnecessary work, but if you consume every element anyway, the benefit may be small. In some cases, eager code is simpler and just as good. **Problem:** This code uses laziness for a tiny collection and immediately materializes the entire result, so there may be no meaningful gain. ```swift let smallList = [1, 2, 3] let output = Array(smallList.lazy.map { $0 * 2 }) ``` **Fix:** Use lazy collections when they solve a real problem, such as long chains, expensive work, or early stopping. ```swift let output = (1...1_000_000).lazy .filter { $0 % 2 == 0 } .prefix(10) print(Array(output)) ``` Output (tested with Swift 6.4): ```text [2, 4, 6, 8, 10, 12, 14, 16, 18, 20] ``` The corrected version is a better fit because laziness helps avoid processing unnecessary values. ### Mistake 3: Confusing lazy collections with lazy properties Swift uses the word `lazy` in more than one place. A lazy property delays initialization of a stored property, while a lazy collection delays sequence operations. **Problem:** This code uses a lazy property and assumes it behaves like a lazy sequence pipeline, but these are different language features. ```swift struct Report { let numbers = [1, 2, 3] lazy var doubled = numbers.map { $0 * 2 } } ``` **Fix:** Use `.lazy` on the sequence when you want deferred element-by-element processing. ```swift let numbers = [1, 2, 3] let doubled = numbers.lazy.map { $0 * 2 } ``` The corrected version works because the lazy behavior now belongs to the collection pipeline itself. ### Mistake 4: Reusing a lazy pipeline with side effects and expecting stable behavior Because lazy work runs when values are accessed, closures with side effects can execute multiple times if the lazy sequence is iterated multiple times. **Problem:** This code increments a counter inside the lazy transformation, so each iteration triggers the side effect again. ```swift var count = 0 let numbers = [1, 2, 3] let lazyValues = numbers.lazy.map { count += 1 return $0 * 2 } print(Array(lazyValues)) print(Array(lazyValues)) print(count) ``` Output (tested with Swift 6.4): ```text [2, 4, 6] [2, 4, 6] 6 ``` **Fix:** Avoid side effects in lazy transformations, or materialize the result once if you need stable repeated access. ```swift let numbers = [1, 2, 3] let computedValues = Array(numbers.lazy.map { $0 * 2 }) print(computedValues) print(computedValues) ``` Output (tested with Swift 6.4): ```text [2, 4, 6] [2, 4, 6] ``` The corrected version works because the transformation is evaluated once and stored in a concrete array. ## 7. Best Practices ### Use lazy when you may stop early Laziness is most helpful when later operations may consume only part of the sequence. ```swift let topMatches = (1...10_000).lazy .filter { $0 % 17 == 0 } .prefix(3) print(Array(topMatches)) ``` Output (tested with Swift 6.4): ```text [17, 34, 51] ``` This is a strong use of laziness because Swift stops after finding the first three matches. ### Keep lazy closures free of side effects Side effects make lazy code harder to reason about because evaluation timing depends on access. ```swift let words = ["swift", "lazy", "map"] let uppercased = words.lazy.map { $0.uppercased() } print(Array(uppercased)) ``` Output (tested with Swift 6.4): ```text ["SWIFT", "LAZY", "MAP"] ``` This transformation is predictable because it only depends on the input values. ### Materialize the result when repeated access matters If you need to traverse the result multiple times, turning it into an array can make behavior clearer and avoid repeated computation. ```swift let numbers = (1...100).lazy.map { $0 * 2 } let storedNumbers = Array(numbers) print(storedNumbers.prefix(5)) print(storedNumbers.suffix(5)) ``` Output (tested with Swift 6.4): ```text [2, 4, 6, 8, 10] [192, 194, 196, 198, 200] ``` This is often better than recalculating the lazy pipeline each time you inspect it. ## 8. Limitations and Edge Cases - A lazy pipeline does not cache results automatically. Iterating again may repeat the work. - Not every use of `lazy` improves performance. Measure if performance matters. - Debugging can be less obvious because transformations happen later than expected. - Closures with side effects can produce confusing results when evaluation timing changes. - If you convert immediately to `Array`, the benefit of laziness may be smaller. - Some operations force full evaluation, so a pipeline may not remain fully lazy from start to finish. - Lazy collections are views over existing data, so changes in surrounding program state can affect what happens at evaluation time. ## 9. Practical Mini Project This mini project scans a range of numbers, keeps only values divisible by both 3 and 5, squares them, and takes the first five results. It demonstrates a realistic lazy pipeline with early stopping. ```swift let specialNumbers = (1...100_000).lazy .filter { $0 % 3 == 0 && $0 % 5 == 0 } .map { $0 * $0 } .prefix(5) let finalValues = Array(specialNumbers) print(finalValues) ``` Output (tested with Swift 6.4): ```text [225, 900, 2025, 3600, 5625] ``` This code is efficient because it does not square every number in the full range. It filters and transforms values only until five matching results have been produced. ## 10. Key Points - `lazy` delays sequence and collection work until values are accessed. - Lazy pipelines are useful with chained operations like `map`, `filter`, and `prefix`. - They can reduce intermediate arrays and avoid unnecessary computation. - Lazy collections are different from lazy stored properties. - Lazy evaluation does not automatically cache results. - Closures with side effects are risky in lazy pipelines because execution timing can surprise you. ## 11. Practice Exercise Try this exercise to confirm that you understand when lazy evaluation helps. - Create a range from 1 to 10,000. - Use a lazy pipeline to keep only numbers divisible by 7. - Convert each matching number into a string like `"Item: 14"`. - Take only the first four results. - Print the final array. **Expected output:** An array containing the first four strings for numbers divisible by 7. **Hint:** Start with the range, add `.lazy`, then chain `filter`, `map`, and `prefix` before converting to `Array`. ```swift let items = (1...10_000).lazy .filter { $0 % 7 == 0 } .map { "Item: \($0)" } .prefix(4) let result = Array(items) print(result) ``` Output (tested with Swift 6.4): ```text ["Item: 7", "Item: 14", "Item: 21", "Item: 28"] ``` ## 12. Final Summary Swift lazy collections are a powerful way to defer work in sequence pipelines. By adding `lazy` before operations like `map` and `filter`, you can avoid unnecessary computation, reduce intermediate storage, and make early-stopping operations such as `prefix` much more efficient. The most important thing to remember is that lazy evaluation changes *when* work happens, not just *how* it looks in code. That means it can improve performance in the right situations, but it can also introduce confusion if you expect immediate execution or rely on side effects. A good next step is to study Swift sequences and collections more deeply, especially how methods like `first`, `prefix`, and `reduce` interact with lazy pipelines.