Block vs Proc vs Lambda in Ruby: Key Differences and Usage

In Ruby, a block is a chunk of code passed to methods, a proc is an object that holds a block and can be stored or passed around, and a lambda is a special kind of proc with stricter argument checking and different return behavior. Blocks are implicit, procs are flexible, and lambdas behave more like methods.

Quick Comparison

Here is a quick table comparing key aspects of blocks, procs, and lambdas in Ruby.

Feature	Block	Proc	Lambda
Type	Anonymous code chunk passed to method	Object wrapping a block	Special kind of proc object
Syntax	do...end or {...}	Proc.new or proc	lambda or -> syntax
Argument Checking	No strict checking	No strict checking	Strict argument checking
Return Behavior	Returns from enclosing method	Returns from enclosing method	Returns from lambda itself
Can be Stored	No (unless converted)	Yes	Yes
Use Case	Simple inline code	Reusable blocks	Function-like behavior

Key Differences

A block in Ruby is a piece of code you pass to a method, but it is not an object by itself. You can only have one block per method call, and it is often used for iteration or callbacks. Blocks do not enforce argument counts strictly and when you use return inside a block, it returns from the method that yielded the block.

A proc is an object created by Proc.new or proc. It wraps a block so you can store it in variables, pass it around, and call it multiple times. Procs do not check the number of arguments strictly, so missing or extra arguments are allowed. When you use return inside a proc, it tries to return from the method where the proc was defined, which can cause unexpected behavior if called elsewhere.

A lambda is a special kind of proc created by lambda or the arrow syntax ->. It behaves more like a method: it checks the number of arguments strictly and raises an error if they don't match. Also, return inside a lambda only exits the lambda itself, not the enclosing method. This makes lambdas safer and more predictable for functional-style programming.

Code Comparison

Here is how you use a block in a method to print numbers:

ruby

def print_numbers
  [1, 2, 3].each do |n|
    puts n
  end
end

print_numbers

Output

1
2
3

Proc Equivalent

Here is the same task using a proc object:

ruby

printer = Proc.new { |n| puts n }

[1, 2, 3].each(&printer)

Output

1
2
3

When to Use Which

Choose a block when you want simple, inline code passed to a method, especially for iteration or callbacks. Use a proc when you need to store a block as an object and reuse it, but don't need strict argument checks. Opt for a lambda when you want function-like behavior with strict argument checking and predictable return behavior, making your code safer and easier to debug.

Key Takeaways

Blocks are simple code chunks passed to methods and are not objects.

Procs are objects wrapping blocks, allowing reuse but with loose argument rules.

Lambdas are strict procs that check arguments and have safer return behavior.

Use blocks for inline code, procs for reusable code, and lambdas for method-like functions.