Lazy enumerators in Ruby - Step-by-Step Execution

Concept Flow - Lazy enumerators

Create Enumerator

↓

Call lazy

↓

Chain operations (map, select)

↓

Trigger evaluation (e.g., first, take)

↓

Process elements one by one

↓

Return results

↓

Stop when done or limit reached

Lazy enumerators delay processing elements until needed, allowing efficient chaining and partial evaluation.

Execution Sample

Ruby

numbers = (1..Float::INFINITY).lazy
result = numbers.select { |x| x % 2 == 0 }.map { |x| x * 10 }.first(5)

This code creates an infinite lazy enumerator of numbers, filters even numbers, multiplies them by 10, and takes the first 5 results.

Execution Table

Step	Operation	Current Element	Condition/Action	Output/Result
1	Start lazy enumerator	1	No output yet	Enumerator created
2	Select even numbers	1	1 % 2 == 0? No	Skip
3	Select even numbers	2	2 % 2 == 0? Yes	Pass
4	Map multiply by 10	2	2 * 10	20
5	Collect first element	20	Add to result	[20]
6	Select even numbers	3	3 % 2 == 0? No	Skip
7	Select even numbers	4	4 % 2 == 0? Yes	Pass
8	Map multiply by 10	4	4 * 10	40
9	Collect second element	40	Add to result	[20, 40]
10	Select even numbers	5	5 % 2 == 0? No	Skip
11	Select even numbers	6	6 % 2 == 0? Yes	Pass
12	Map multiply by 10	6	6 * 10	60
13	Collect third element	60	Add to result	[20, 40, 60]
14	Select even numbers	7	7 % 2 == 0? No	Skip
15	Select even numbers	8	8 % 2 == 0? Yes	Pass
16	Map multiply by 10	8	8 * 10	80
17	Collect fourth element	80	Add to result	[20, 40, 60, 80]
18	Select even numbers	9	9 % 2 == 0? No	Skip
19	Select even numbers	10	10 % 2 == 0? Yes	Pass
20	Map multiply by 10	10	10 * 10	100
21	Collect fifth element	100	Add to result	[20, 40, 60, 80, 100]
22	Stop	N/A	Collected 5 elements	Result ready

💡 Collected 5 elements, so evaluation stops early without processing infinite elements.

Variable Tracker

Variable	Start	After Step 4	After Step 9	After Step 13	After Step 17	After Step 21	Final
current_element	1	2	4	6	8	10	10
result	[]	[20]	[20, 40]	[20, 40, 60]	[20, 40, 60, 80]	[20, 40, 60, 80, 100]	[20, 40, 60, 80, 100]

Key Moments - 3 Insights

Why doesn't the code try to process all infinite numbers?

Because the lazy enumerator only processes elements as needed. The 'first(5)' call stops after collecting 5 results, so it never evaluates the infinite rest. See execution_table rows 21-22.

Why do some numbers get skipped in the process?

Numbers that don't meet the 'select' condition (even numbers) are skipped immediately without mapping. For example, 1 is skipped at step 2. This saves work and is shown in execution_table rows 2, 6, 10, 14, 18.

When does the 'map' operation happen?

The 'map' runs only on numbers that passed the 'select' filter. For example, 2 passes select and then is multiplied by 10 at step 4. This chaining is lazy and happens element by element.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output after step 9?

A [20, 40]

B [20]

C [20, 40, 60]

D []

💡 Hint

Check the 'Output/Result' column at step 9 in the execution_table.

At which step does the lazy enumerator stop processing elements?

A Step 10

B Step 22

C Step 21

D Step 5

💡 Hint

Look for the step where the exit note says 'Result ready' in the execution_table.

If we change 'first(5)' to 'first(3)', what would be the output after step 9?

A [20, 40]

B [20]

C [20, 40, 60]

D []

💡 Hint

Refer to variable_tracker and execution_table to see how many elements are collected by step 9.

Concept Snapshot

Lazy enumerators delay processing until needed.
Use 'lazy' on enumerables to chain operations efficiently.
Operations like 'map' and 'select' are chained but not run immediately.
Trigger evaluation with methods like 'first', 'take', or 'to_a'.
Useful for infinite or large data to avoid unnecessary work.

Full Transcript

This visual trace shows how Ruby's lazy enumerators work step-by-step. We start with an infinite range and call 'lazy' to create a lazy enumerator. Then we chain 'select' to filter even numbers and 'map' to multiply by 10. The key is that no elements are processed until we call 'first(5)', which triggers evaluation. The enumerator processes elements one by one, skipping odd numbers and transforming even numbers, collecting results until it has 5 elements. It stops early without processing the infinite rest. Variables like 'current_element' and 'result' update as we go. This approach saves time and memory by doing only what is needed.