What is the difference between blocks, procs and lambdas?

Question

Accepted Answer

These are three ways Ruby handles **chunks of code as data**. A **block** is passed to a method (not an object); a **Proc** and a **lambda** are objects that wrap a block (callable, storable). Procs and lambdas differ subtly in argument checking and `return` behavior.

## Blocks — passed to methods (not objects)

```ruby
[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
```

A block is the code passed to a method (in `{ }` or `do...end`) — it's not a standalone object you can store; it's tied to the method call.

## Procs and lambdas — blocks as storable objects

```ruby
# 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 and lambdas wrap a block into an **object** you can assign to variables, pass around, and call later (`.call`) — useful for storing reusable behavior.

## The key differences: arguments and return

```text
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!)
```

```ruby
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
```

The most important difference: a **lambda behaves like a method** (strict arguments, `return` exits just the lambda), while a **proc is more lenient** (ignores argument mismatches, and `return` exits the enclosing method — which can cause surprising behavior). **Lambdas are generally preferred** for their method-like, predictable behavior.

## Why it matters

Understanding blocks, procs, and lambdas — and especially their differences — is important Ruby knowledge that reflects deeper understanding of how Ruby handles code as data. **Blocks** are the most common (passed to methods for iteration and callbacks — Ruby's signature feature), while **procs and lambdas** turn blocks into storable, reusable objects you can assign to variables, pass around, and call later (useful for storing behavior, building functional patterns, and passing callbacks as values).

The **key differences between procs and lambdas** are subtle but important and a frequent interview topic: **argument checking** (lambdas are strict like methods, procs are lenient) and especially **`return` behavior** (a lambda's `return` exits just the lambda, while a proc's `return` exits the *enclosing method* — which can cause surprising, hard-to-debug behavior).

Understanding these distinctions — that a **lambda behaves like a method** (strict, predictable, with localized return) while a **proc is more lenient with surprising return semantics** — is important for using them correctly and for the common recommendation to **prefer lambdas** for their predictable, method-like behavior.

While blocks are everyday Ruby and procs/lambdas are used for storable callbacks and functional patterns, understanding all three (especially the proc-vs-lambda return and argument differences) reflects solid Ruby knowledge, helps you avoid the proc-return gotcha, and is a classic interview topic that distinguishes developers who truly understand Ruby's handling of code as objects.