Estas são três formas de Ruby lidar com chunks de código como dados. Um bloco é passado para um método (não é um objeto); um Proc e uma lambda são objetos que envolvem um bloco (callable, armazenável). Procs e lambdas diferem sutilmente na validação de argumentos e no comportamento de return.
[1, 2, 3].each { |n| puts n } # the { } is a block — passed to each
# a block is NOT an object; it's part of the method call, can't be stored in a variable directly
Um bloco é o código passado para um método (em { } ou do...end) — não é um objeto independente que você pode armazenar; está vinculado à chamada do método.
# a Proc — a block turned into an object you can store and call
square = Proc.new { |x| x * x }
square.call(5) # 25
square.(5) # 25 (alternate call syntax)
# a lambda — also a callable object (a "stricter" Proc)
double = lambda { |x| x * 2 }
double = ->(x) { x * 2 } # the -> "stabby lambda" syntax
double.call(5) # 10
Procs e lambdas envolvem um bloco em um objeto que você pode atribuir a variáveis, passar por aí e chamar depois (.call) — útil para armazenar comportamento reutilizável.
1. ARGUMENT CHECKING:
lambda → STRICT: errors if wrong number of arguments (like a method)
proc → LENIENT: ignores extra args, fills missing with nil
2. RETURN behavior:
lambda → `return` returns from the LAMBDA (like a normal method)
proc → `return` returns from the ENCLOSING METHOD (can surprise you!)
def test_proc
p = Proc.new { return 10 }
p.call # returns from test_proc ENTIRELY → 10
return 20 # never reached!
end
def test_lambda
l = lambda { return 10 }
l.call # returns from the LAMBDA only → 10
return 20 # reached → test_lambda returns 20
end
A diferença mais importante: uma lambda se comporta como um método (argumentos estritos, return sai apenas da lambda), enquanto um proc é mais leniente (ignora incompatibilidades de argumentos, e return sai do método envolvente — o que pode causar comportamento surpreendente). Lambdas são geralmente preferidas por seu comportamento previsível similar ao de métodos.
Compreender blocos, procs e lambdas — e especialmente suas diferenças — é conhecimento importante de Ruby que reflete compreensão mais profunda de como Ruby lida com código como dados. Blocos são os mais comuns (passados para métodos para iteração e callbacks — a característica assinatura do Ruby), enquanto procs e lambdas transformam blocos em objetos armazenáveis e reutilizáveis que você pode atribuir a variáveis, passar por aí e chamar depois (úteis para armazenar comportamento, construir padrões funcionais e passar callbacks como valores).
As diferenças principais entre procs e lambdas são sutis mas importantes e um tópico frequente em entrevistas: validação de argumentos (lambdas são estritas como métodos, procs são lenientes) e especialmente comportamento de return (o return de uma lambda sai apenas da lambda, enquanto o return de um proc sai do método envolvente — o que pode causar comportamento surpreendente e difícil de debugar).
Compreender essas distinções — que uma lambda se comporta como um método (estrita, previsível, com return localizado) enquanto um proc é mais leniente com semântica de return surpreendente — é importante para usá-los corretamente e para a recomendação comum de preferir lambdas por seu comportamento previsível e similar ao de métodos.
Enquanto blocos são Ruby do dia a dia e procs/lambdas são usados para callbacks armazenáveis e padrões funcionais, compreender todos os três (especialmente as diferenças de return e argumentos entre proc e lambda) reflete conhecimento sólido de Ruby, ajuda você a evitar a armadilha do proc-return e é um tópico clássico de entrevista que diferencia desenvolvedores que realmente entendem o tratamento de código como objetos pelo Ruby.