Proc vs Lambda, ou la fonction et le fragment Proc vs Lambda, the function and the fragment

Un bloc qu'on garde sous la main devient un objet qu'on rappelle.A block you keep around becomes an object you call back.

Au numéro précédent, le bloc partait avec l'appel et la méthode le rappelait via yield. Mais on peut aussi le capturer dans un objet : une lambda (->) ou un proc. Cet objet se range dans une variable, se passe en argument, se rappelle plus tard avec .call. Deux façons de l'écrire, qui semblent interchangeables — et qui, on va le voir, ne le sont pas du tout.Last issue, the block left with the call and the method called it back via yield. But you can also capture it in an object: a lambda (->) or a proc. That object goes into a variable, gets passed as an argument, gets called later with .call. Two ways to write it, seemingly interchangeable — and, as we'll see, not at all.

add = ->(a, b) { a + b }   # une lambda : un bloc capturé dans un objet
add.call(1, 2)             # => 3   — la forme explicite
add.(1, 2)                 # => 3   — le sucre .()
add[1, 2]                  # => 3   — et même []

square = proc { |x| x * x }  # un proc : l'autre objet-fonction
square.call(5)               # => 25

add.class                  # => Proc   — les deux sont des Proc
add.lambda?                # => true   — mais celui-ci se sait lambda

Même classe, même syntaxe d'appel — et deux comportements opposés.Same class, same call syntax — and two opposite behaviors.

proc et lambda se ressemblent à s'y méprendre : même classe Proc, même .call. La différence tient en deux points, et ils décident lequel choisir. L'arité : la lambda exige le bon nombre d'arguments, le proc s'en arrange. Le return : dans une lambda il sort de la lambda, dans un proc il sort de la méthode qui l'entoure. Ce ne sont pas des détails — ce sont deux outils différents.proc and lambda look deceptively alike: same Proc class, same .call. The difference comes down to two points, and they decide which to pick. Arity: the lambda demands the right number of arguments, the proc shrugs it off. return: in a lambda it exits the lambda, in a proc it exits the enclosing method. These aren't details — they're two different tools.

lam  = ->(a, b) { [a, b] }
prc  = proc { |a, b| [a, b] }

lam.call(1)        # ArgumentError: wrong number of arguments (given 1, expected 2)
lam.call(1, 2, 3)  # ArgumentError aussi — la lambda EXIGE la bonne arité

prc.call(1)        # => [1, nil]   — manquant ? rempli avec nil, sans broncher
prc.call(1, 2, 3)  # => [1, 2]     — en trop ? ignoré, sans broncher
# le proc est laxiste : c'est pratique… jusqu'à ce que ça masque un bug

La lambda se comporte comme une méthode : le mauvais nombre d'arguments lève une ArgumentError, tout de suite. Le proc avale tout — un argument manquant devient nil, un argument en trop disparaît. Souple, mais silencieux.The lambda behaves like a method: the wrong number of arguments raises ArgumentError, right away. The proc swallows everything — a missing argument becomes nil, an extra one vanishes. Flexible, but silent.

Le & est un traducteur : entre « bloc » et « objet Proc ».The & is a translator: between "block" and "Proc object".

Un bloc n'est pas un objet ; un Proc, si. Le & fait le pont entre les deux. En paramètre (&block), il capture le bloc passé dans un Proc nommé. À l'appel (map(&doubler)), il reconvertit un Proc en bloc. Et &:symbol n'est qu'un cas particulier : il demande au Symbol de se transformer en Proc. Trois usages, une seule idée — convertir.A block isn't an object; a Proc is. The & bridges the two. As a parameter (&block), it captures the passed block into a named Proc. At the call site (map(&doubler)), it converts a Proc back into a block. And &:symbol is just a special case: it asks the Symbol to turn itself into a Proc. Three uses, one idea — convert.

# & dans les DEUX sens : capturer le bloc, ou transmettre un Proc

def measure(&block)        # & capture le bloc passé DANS un Proc nommé block
  start = Time.now
  block.call               # on l'appelle comme un objet
  Time.now - start
end
measure { sleep 0.1 }      # => ~0.1

doubler = ->(x) { x * 2 }
[1, 2, 3].map(&doubler)    # & RECONVERTIT le Proc en bloc pour map → [2, 4, 6]

# &:symbol — l'idiome le plus courant, et ce qu'il cache
[1, 2, 3].map(&:to_s)      # => ["1", "2", "3"]

# &:to_s appelle Symbol#to_proc, qui fabrique :
->(x) { x.to_s }
# donc map(&:to_s) est exactement map { |x| x.to_s }
%w[a b].map(&:upcase)      # => ["A", "B"]

map(&:to_s) n'est pas une syntaxe magique : le & demande à :to_s de devenir un Proc (Symbol#to_proc), qui envoie simplement le message to_s à chaque élément. Concis tant que le bloc tient en un seul message sans argument — au-delà, il faut revenir au bloc explicite.map(&:to_s) isn't magic syntax: the & asks :to_s to become a Proc (Symbol#to_proc), which simply sends the to_s message to each element. Concise as long as the block is a single argument-less message — beyond that, you must return to an explicit block.

Prendre un proc pour une fonction, c'est hériter d'un return qui ne t'appartient pas.Taking a proc for a function means inheriting a return that isn't yours.

Quand on veut un objet-fonction — qu'on stocke, qu'on passe, qu'on rappelle plus tard — le réflexe est d'écrire proc { … }. C'est le mauvais outil. Le return d'un proc veut sortir de la méthode qui l'a créé ; appelé après coup, il lève LocalJumpError. Et son arité laxiste avale les erreurs d'appel au lieu de les signaler. Une fonction autonome veut une lambda : return local, arité stricte.When you want a function-object — stored, passed, called back later — the reflex is to write proc { … }. Wrong tool. A proc's return wants to exit the method that created it; called afterward, it raises LocalJumpError. And its lax arity swallows call errors instead of flagging them. A self-contained function wants a lambda: local return, strict arity.

# Le réflexe : "un objet-fonction, je prends proc"
def make_validator
  proc { |x| return false if x.nil?; x > 0 }
end

check = make_validator      # make_validator a déjà rendu la main…
check.call(5)
# LocalJumpError: unexpected return
# … le return du proc cherche à sortir d'une méthode qui n'existe plus

# Le correctif : une fonction autonome, c'est une LAMBDA
def make_validator
  ->(x) { return false if x.nil?; x > 0 }
end

check = make_validator
check.call(nil)   # => false   — le return sort de la lambda, proprement
check.call(5)     # => true
check.call        # ArgumentError — et l'arité stricte attrape l'appel fautif