Sequences & Lazy Pipelines

Intermediate operations like map and filter just describe work and return a new sequence without doing anything yet. Terminal operations like toList or sum actually run the pipeline and give you a final result.

sequence{} creates a lazy sequence. Inside the block you call yield(x) to hand out one value at a time, only producing them as the consumer asks for them.

asSequence() makes the chain lazy. Instead of building a new list after each map/filter, each element flows through every step one at a time, only when a result is finally needed.

A List runs each step fully and makes a new list every step. A Sequence is lazy: it pulls one element all the way through the chain. Use Sequences for long chains over large data.

Each element is pushed through map then filter one at a time, not all maps first. The take(2) stops the whole thing as soon as two elements pass, so later elements are never touched.

On a List each step finishes for all elements first, so you see all filters then all maps. On a Sequence each element travels through filter then map before the next, so the output is interleaved.

A Sequence pulls elements one by one. Terminal operations like first, find, take, and any stop the moment they have their answer, so the rest of the data is never touched.

Because each Fibonacci number needs the two before it, you make the element a pair (a, b). The seed is the first pair, and next turns (a, b) into (b, a+b). Then map each pair to its first number.

It's a version where you give just one function that produces each next value (using outside state), and it stops when that function returns null. Great for reading until there's nothing left, like lines from a file.

Some sequences can only be iterated once, so running a second terminal op on them throws. A sequence built from a collection can be re-run. And without any terminal op, the chain never executes at all.

Each iteration re-runs the builder block from the top. So the values are recomputed, and any side effects (like printing) happen again every time you consume the sequence.

yield emits one element. yieldAll emits a whole group at once. yieldAll works with a list/iterable, another sequence, or an iterator — and it stays lazy.

Each List operator returns a brand-new list, so filter→map→take makes three intermediate lists. A Sequence just wraps the previous step lazily and pushes elements one by one, so it makes zero intermediate lists until the terminal collector.

Sequences add overhead per element: iterator objects and lambda calls for every step. On small lists or a single operation, that overhead beats the savings, so plain List operators are faster.

Use generateSequence when the data is unbounded or you only need part of it, so you don't compute or store more than necessary. If you need the whole finite set and will reuse it many times, an eager list can be simpler and faster.

Stateless intermediate ops like map and filter handle one element at a time. Stateful ones like sorted and distinct need to look at many or all elements, so they can break laziness and will hang on an infinite sequence.

The sequence builder is built on a restricted kind of coroutine. The compiler only lets you call yield/yieldAll inside it, so you can't await real async work like delay().

Because work is deferred until a terminal op, side effects in map/filter don't run when you write them, exceptions surface later, and some sequences can only be iterated once or re-run their work on each terminal call.

Eager makes a new list at every step and walks the whole data once per step. A Sequence makes no intermediate lists and walks each element once through all steps, stopping early if a terminal allows.

onEach is intermediate: it runs a side effect on each element but passes the element along, so the chain keeps going lazily. forEach is terminal: it runs a side effect and ends the chain, returning nothing.

Make each element a page. Start by fetching the first page (seed), then next fetches the page after the current one using its cursor, returning null when there's no next page. Flatten the pages into items and take what you need.

iterator{} works just like sequence{} but returns an Iterator instead of a Sequence. Use sequence{} when generation logic is branchy or recursive, or when the stream is infinite/expensive and you want laziness.

Laziness helps with large inputs, long chains, or when you need only part of the result (first/take): it skips intermediate lists and stops early. For tiny inputs or a single operator it adds overhead and can be neutral or slower.

Return a List when results are small, finite, and reused; return a Sequence when data may be large or infinite and callers can stream and stop early. Warn that Sequences are lazy and may be single-use.