Closures & la capture du contexte Closures & capturing the context

Le bloc n'emporte pas que du code. Il emporte l'endroit où il est né.A block carries more than code. It carries the place it was born.

On a capturé un bloc dans un objet (proc, lambda). Voici ce qu'on n'avait pas dit : cet objet n'emporte pas que les instructions — il emporte les variables locales qui l'entouraient à sa naissance. La lambda renvoyée par make_counter continue de voir count, et de le modifier, longtemps après que make_counter a rendu la main. C'est une closure : un bloc qui se referme sur son environnement.We captured a block in an object (proc, lambda). Here's what we hadn't said: that object carries more than the instructions — it carries the local variables that surrounded it at birth. The lambda returned by make_counter keeps seeing count, and mutating it, long after make_counter has returned. That's a closure: a block that closes over its environment.

def make_counter
  count = 0                 # une variable locale à make_counter
  -> { count += 1 }         # la lambda VOIT count, et le garde
end

c = make_counter            # make_counter a fini, count "devrait" disparaître…
c.call                      # => 1
c.call                      # => 2   — count survit, et se souvient
c.call                      # => 3

d = make_counter            # un AUTRE compteur, son propre count
d.call                      # => 1   — indépendant de c

La closure ne photographie pas une valeur. Elle tient la variable.A closure doesn't snapshot a value. It holds the variable.

L'intuition trompeuse : on imagine que le bloc « capture » la valeur de x au moment où il est créé, comme une photo. Faux. Il capture la variable elle-même — la case mémoire, pas son contenu. Si x change ensuite, le bloc voit la nouvelle valeur ; et s'il assigne x, c'est le x extérieur qu'il modifie. C'est exactement ce qui rend make_counter possible — et ce qui piège dans une boucle.The misleading intuition: you imagine the block 'captures' the value of x at creation time, like a photo. Wrong. It captures the variable itself — the memory slot, not its contents. If x changes afterward, the block sees the new value; and if it assigns x, it mutates the outer x. That's exactly what makes make_counter possible — and what traps you in a loop.

# Ce qu'on CROIT : la closure photographie la valeur à sa création
x = 1
f = -> { x }
x = 2
f.call
# attendu (à tort) : 1  — "la lambda a capturé x quand x valait 1"

On suppose que f a figé x = 1 à sa création, et qu'un changement ultérieur de x ne le concerne plus. C'est le modèle mental qu'on apporte d'ailleurs — et il est faux en Ruby.You assume f froze x = 1 at creation, and that a later change to x no longer concerns it. That's the mental model you bring from elsewhere — and it's wrong in Ruby.

On mute ce qui existait. On garde dedans ce qu'on crée.You mutate what existed. You keep inside what you create.

La règle de portée d'un bloc tient en une phrase : il voit les variables locales qui l'entourent, donc il peut les lire et les modifier ; mais une variable créée à l'intérieur du bloc reste locale au bloc et ne fuit pas dehors. Les paramètres du bloc sont eux aussi locaux. Et si tu veux protéger une variable extérieure d'une écriture accidentelle, le ; la déclare explicitement locale.A block's scope rule fits in one sentence: it sees the local variables around it, so it can read and mutate them; but a variable created inside the block stays block-local and doesn't leak out. The block's parameters are local too. And if you want to protect an outer variable from accidental writes, the ; declares it explicitly local.

total = 0
[1, 2, 3].each do |n|       # n : paramètre, local au bloc
  total += n                # total existe DEHORS → on le mute
  doubled = n * 2           # doubled est NOUVELLE → locale au bloc
end

total      # => 6        — la mutation a traversé
doubled    # NameError   — doubled n'a jamais existé hors du bloc
# règle : on lit/mute ce qui existe déjà ; ce qu'on crée reste dedans

x = "dehors"
[1, 2].each { |n; x| x = n }   # le ; x déclare x LOCAL au bloc
x          # => "dehors"       — l'extérieur est protégé

# sans le ; x, le bloc aurait écrasé le x extérieur :
[1, 2].each { |n| x = n }
x          # => 2              — clobbered

def snapshot
  secret = 42
  binding              # un objet Binding : l'environnement capturé, réifié
end

b = snapshot
b.local_variable_get(:secret)   # => 42  — on relit la variable à distance
b.eval("secret + 1")            # => 43  — on exécute DANS ce contexte
# c'est ce que toute closure tient implicitement : un binding

Le Binding renvoyé par snapshot garde secret en vie après le retour de la méthode — exactement comme make_counter gardait count. La closure n'a rien de magique : elle tient une référence vers un environnement, et tant qu'elle vit, cet environnement vit aussi. D'où la puissance — et la rétention mémoire qu'on verra au piège.The Binding returned by snapshot keeps secret alive after the method returns — exactly as make_counter kept count. A closure isn't magic: it holds a reference to an environment, and as long as it lives, that environment lives too. Hence the power — and the memory retention we'll see in the trap.

Trois closures, une seule variable — et le résultat te surprend.Three closures, one variable — and the result surprises you.

Tout ce qui précède était un cadeau : la closure capture la variable vivante. Voici la facture. Si tu fabriques plusieurs closures dans une boucle while, elles capturent toutes la même variable de boucle — et à l'appel, elles lisent sa valeur finale, identique pour toutes. Le bug classique des closures, et il vient directement du « par référence » du № 2.Everything above was a gift: the closure captures the live variable. Here's the bill. If you build several closures in a while loop, they all capture the same loop variable — and at call time, they read its final value, identical for all. The classic closure bug, straight from the 'by reference' of № 2.

# Le réflexe : construire des closures dans une boucle while
handlers = []
i = 0
while i < 3
  handlers << -> { i }     # chaque lambda capture LE MÊME i
  i += 1
end

handlers.map(&:call)       # => [3, 3, 3]   (et non [0, 1, 2] !)
# il n'y a qu'un seul i ; à l'appel, il vaut 3. Les trois closures
# pointent la même variable — celle que la boucle a fait grimper.

# Le correctif : un itérateur à bloc donne un i FRAIS par tour
handlers = []
3.times { |i| handlers << -> { i } }   # i est un paramètre de bloc :
                                        # une nouvelle variable à chaque tour
handlers.map(&:call)       # => [0, 1, 2]   — chacune sa propre capture

# et si tu tiens à ton while ? repasse quand même par un paramètre de bloc.
# une locale posée DANS le while ne sauverait rien : while n'ouvre aucune
# portée, ce serait encore UNE variable pour trois closures.
handlers = []
i = 0
while i < 3
  i.then { |snapshot| handlers << -> { snapshot } }   # snapshot est un
  i += 1                                             # paramètre de bloc :
end                                                  # neuf à chaque tour
handlers.map(&:call)       # => [0, 1, 2]