lazy & les Enumerator, ou le calcul tiré par la demande lazy & Enumerators, or computation pulled by demand

Une chaîne stricte alloue à chaque maillon — lazy diffère tout.A strict chain allocates at every link — lazy defers it all.

Le raffinement, dernier étage du volume. Une chaîne map.select.first est lisible, mais chaque maillon construit un tableau intermédiaire complet avant de passer le relais : map alloue tout, puis select alloue tout, et first n'en retient que cinq. Sur un million d'éléments, ce sont deux tableaux intermédiaires — un million de cases, puis encore plus de trois cent mille — pour cinq résultats ; sur une séquence infinie, c'est impossible — la première étape ne finit jamais. lazy renverse l'ordre : rien n'est calculé tant qu'on ne demande pas, et la donnée traverse alors la chaîne un élément à la fois, jusqu'à ce que first(5) dise stop. Le calcul suit la demande, pas la source.The refinement, the volume's top floor. A map.select.first chain is readable, but each link builds a full intermediate array before handing over: map allocates everything, then select allocates everything, and first keeps only five. On a million elements, that's two intermediate arrays — a million slots, then over three hundred thousand more — for five results; on an infinite sequence, it's impossible — the first step never finishes. lazy reverses the order: nothing is computed until you ask, and the data then crosses the chain one element at a time, until first(5) says stop. The computation follows the demand, not the source.

# strict : chaque maillon construit un Array COMPLET, puis le suivant
(1..1_000_000)
  .map    { |x| x * 2 }        # alloue un Array d'un million…
  .select { |x| x % 3 == 0 }   # … puis un autre Array…
  .first(5)                    # … pour n'en garder que CINQ

# lazy : rien ne se calcule avant first(5), élément par élément
(1..Float::INFINITY).lazy      # une séquence INFINIE, sans broncher
  .map    { |x| x * 2 }
  .select { |x| x % 3 == 0 }
  .first(5)                    # => [6, 12, 18, 24, 30]  5 éléments calculés

L'infini devient calculable — quand la demande tire le calcul.The infinite becomes computable — when demand pulls the computation.

La surprise du numéro : lazy ne fait pas que gagner des allocations, il rend possible ce qui ne l'était pas. Une chaîne stricte sur une séquence infinie ne rend jamais la main — map veut d'abord mapper tout l'infini. En lazy, la logique s'inverse : c'est le consommateur final (first, take, find) qui réclame des éléments, et la chaîne n'en produit que juste assez pour le satisfaire. Le calcul est tiré par la demande, pas poussé par la source. Du coup, (1..∞).lazy compose comme un tableau ordinaire, et first(3) arrête la production dès le troisième résultat trouvé.The issue's surprise: lazy doesn't only save allocations, it makes possible what wasn't. A strict chain over an infinite sequence never returns — map wants to map all of infinity first. In lazy, the logic flips: it's the final consumer (first, take, find) that requests elements, and the chain produces only just enough to satisfy it. The computation is pulled by demand, not pushed by the source. So (1..∞).lazy composes like an ordinary array, and first(3) stops production at the third result found.

# strict sur l'infini : la première étape ne finit JAMAIS
(1..Float::INFINITY)
  .map { |x| x * x }       # tente de mapper… l'infini.
  .first(3)
# le programme part en boucle, ne rend rien, mange la mémoire :
# map veut son Array complet AVANT de passer la main à first

En strict, chaque méthode matérialise son résultat complet avant la suivante. Sur (1..Float::INFINITY), map n'a pas de « résultat complet » : il boucle sans fin, la mémoire enfle, first(3) n'est jamais atteint. La composition fonctionnelle, si élégante au № 2, se heurte ici au mur de l'évaluation stricte.In strict mode, each method materializes its full result before the next. On (1..Float::INFINITY), map has no "full result": it loops forever, memory swells, first(3) is never reached. The functional composition, so elegant in № 2, hits the wall of strict evaluation here.

L'Enumerator : l'itération devenue objet — qu'on tire ou qu'on confie.The Enumerator: iteration become an object — pulled or handed over.

Sous lazy se cache l'Enumerator : un objet qui réifie le parcours lui-même. Appelle each sans bloc et tu en reçois un — un parcours mis en pause, qu'on fait avancer à la demande avec next, ou qu'on inspecte avec peek sans bouger. Enumerator.new te laisse fabriquer tes propres séquences en yieldant des valeurs (y << n), y compris infinies via une boucle. Et tout Enumerator devient paresseux avec .lazy, donc composable sur l'infini comme au chapitre précédent. C'est la même itération vue de deux côtés : externe quand on tire les éléments un à un (next), interne quand on confie un bloc (each, map). L'Enumerator est l'objet qui rend les deux possibles.Beneath lazy sits the Enumerator: an object that reifies traversal itself. Call each with no block and you get one — a paused traversal you advance on demand with next, or inspect with peek without moving. Enumerator.new lets you build your own sequences by yielding values (y << n), infinite ones included via a loop. And any Enumerator becomes lazy with .lazy, hence composable over infinity as in the previous chapter. It's the same iteration seen from two sides: external when you pull elements one by one (next), internal when you hand over a block (each, map). The Enumerator is the object making both possible.

# un each SANS bloc rend un Enumerator : un objet-itération réifié
e = [10, 20, 30].each      # => #<Enumerator>
e.next                     # => 10   on tire un élément…
e.peek                     # => 20   on regarde le suivant SANS avancer
e.next                     # => 20   … puis on avance

# Enumerator.new : fabriquer sa propre séquence, même infinie
naturals = Enumerator.new do |y|
  n = 1
  loop { y << n; n += 1 }   # y << valeur : « produit cet élément »
end
naturals.next              # => 1
naturals.next              # => 2

# un Enumerator est paresseux-able : on compose sur l'infini
naturals.lazy
  .select { |n| n % 7 == 0 }
  .map    { |n| n * n }
  .first(3)                # => [49, 196, 441]

# next/peek = itération EXTERNE (on tire) ; each/map = interne (on confie)
# les deux faces du même Enumerator — selon qui mène la boucle

Boucle avec le Vol 1 : un Enumerator est un objet comme un autre, à qui l'on envoie next, peek, map, lazy. L'itération n'est pas une construction du langage — c'est un objet qu'on manipule, qu'on stocke, qu'on passe en argument. Même la boucle, en Ruby, est un message.A loop back to Vol 1: an Enumerator is an object like any other, to which you send next, peek, map, lazy. Iteration isn't a language construct — it's an object you manipulate, store, pass as an argument. Even the loop, in Ruby, is a message.

lazy sur dix éléments : l'overhead coûte plus que le gain.lazy on ten elements: the overhead costs more than the gain.

Le contre-exemple obligatoire, et l'erreur du dev fraîchement converti à lazy : le dégainer partout. Sur une petite collection qu'on consomme entièrement, lazy est plus lent que la chaîne stricte — et pour rien. Chaque élément doit traverser l'enrobage Enumerator::Lazy, fait d'objets et d'appels indirects, là où map et select strictes tournent dans des boucles C optimisées. Le seul bénéfice de lazy — éviter les tableaux intermédiaires — ne vaut que si ces tableaux sont gros, ou si on s'arrête tôt. Deux Array de dix cases ne coûtent rien ; les éviter au prix de l'overhead Enumerator est une perte sèche. lazy n'est pas « la version rapide » : c'est l'outil de l'énorme, de l'infini, et de l'arrêt anticipé.The mandatory counter-example, and the freshly-converted dev's mistake: reaching for lazy everywhere. On a small collection consumed fully, lazy is slower than the strict chain — and for nothing. Each element must cross the Enumerator::Lazy wrapper, made of objects and indirect calls, where strict map and select run in optimized C loops. lazy's only benefit — avoiding intermediate arrays — is worth it only if those arrays are big, or if you stop early. Two ten-slot arrays cost nothing; avoiding them at the price of Enumerator overhead is a pure loss. lazy isn't 'the fast version': it's the tool of the huge, the infinite, and early termination.

# Le piège : lazy sur une petite collection consommée en entier
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  .lazy
  .map { |x| x * 2 }
  .select { |x| x % 3 == 0 }
  .to_a                    # => [6, 12, 18]  on matérialise TOUT de toute façon

# coût caché : chaque élément traverse l'enrobage Enumerator::Lazy —
# objets et appels indirects — pour économiser deux Array de 10 cases
# parfaitement négligeables. Plus lent, pour aucun gain réel.

# Strict : deux petits intermédiaires, mais des boucles C optimisées
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  .map { |x| x * 2 }
  .select { |x| x % 3 == 0 }   # => [6, 12, 18]
                               # plus rapide ET plus simple à cette taille

# la règle : lazy paie quand…
#   · la source est énorme OU infinie
#   · ET on n'en consomme qu'une PARTIE (first, take, find, lazy.first)
# sinon, sur du petit consommé en entier, le strict gagne toujours.