Introduction: Why Closures Matter in Ruby
If you have spent even an hour writing Ruby code, you have likely encountered a block. Whether it is iterating over an array with .each or opening a file with File.open, Ruby’s use of blocks is one of its most defining and powerful features. But as you move from a beginner to an intermediate developer, you start hearing terms like “Procs” and “Lambdas.” You might wonder: why do we need three different ways to handle snippets of code?
The concept of “closures”—anonymous functions that carry their environment with them—is central to Ruby’s philosophy of developer happiness. Understanding the nuances between blocks, procs, and lambdas is the difference between writing “working” code and writing “elegant, professional” code. Misusing these can lead to unexpected LocalJumpError exceptions or subtle bugs in how your application handles logic flow.
In this guide, we will dive deep into the world of Ruby closures. We will start with the basics, move into the technical differences, and finish with advanced patterns that will make your code more modular and reusable. By the end of this article, you will not just know how to use them, but when and why to choose one over the others.
1. The Foundation: Understanding Ruby Blocks
A block is the simplest form of a closure in Ruby. It is a chunk of code that you pass to a method. Unlike almost everything else in Ruby, a block is not an object. It is a part of the syntax of a method call.
The Two Syntaxes
There are two ways to define a block in Ruby:
- The
do...endsyntax: Generally used for multi-line blocks. - The
{...}(curly braces) syntax: Generally used for single-line blocks.
# Example 1: Multi-line block
[1, 2, 3].each do |number|
puts "Current number: #{number}"
end
# Example 2: Single-line block
[1, 2, 3].each { |number| puts "Current number: #{number}" }
Using the yield Keyword
To write a method that accepts a block, you use the yield keyword. When a method hits a yield, it “yields” control to the block, executes it, and then returns to the method.
def simple_greeting
puts "Before the block"
yield # This executes the block passed to the method
puts "After the block"
end
simple_greeting { puts "Hello from inside the block!" }
# Output:
# Before the block
# Hello from inside the block!
# After the block
Handling Optional Blocks
If you call yield but no block is provided, Ruby will raise a LocalJumpError. To prevent this, use block_given?.
def safe_yield
if block_given?
yield
else
puts "No block was provided!"
end
end
safe_yield # Output: No block was provided!
2. Stepping Up to Procs
While blocks are great, they have a limitation: you can only pass one block to a method, and you can’t save a block for later. This is where Procs (Procedure objects) come in. A Proc is essentially a block that has been saved into a variable.
Creating and Calling a Proc
You can create a Proc using Proc.new. To execute it, you use the .call method.
# Defining a Proc
square_proc = Proc.new { |n| n * n }
# Calling the Proc
result = square_proc.call(5)
puts result # Output: 25
# You can also use alternate call syntaxes
puts square_proc[10] # Output: 100
puts square_proc.(3) # Output: 9
Why use Procs instead of Blocks?
Since Procs are objects, they can be passed around as arguments, stored in data structures, or returned from other methods. This makes your code DRY (Don’t Repeat Yourself).
# Storing logic in a hash
operations = {
add: Proc.new { |a, b| a + b },
subtract: Proc.new { |a, b| a - b }
}
puts operations[:add].call(10, 5) # Output: 15
3. The Precision of Lambdas
Lambdas are a specific type of Proc. They are almost identical but have two critical differences (which we will cover in the next section). In many functional programming contexts, lambdas are preferred because they behave more like standard methods.
Defining Lambdas
There are two common syntaxes for lambdas:
# Traditional syntax
my_lambda = lambda { |x| x + 1 }
# Stabby lambda syntax (more modern and popular)
stabby_lambda = ->(x) { x + 1 }
puts my_lambda.call(10) # Output: 11
puts stabby_lambda.call(10) # Output: 11
4. Procs vs. Lambdas: The Crucial Differences
This is often the most confusing part for developers. There are two primary distinctions between Procs and Lambdas: Argument Enforcement and Return Behavior.
Difference 1: Argument Enforcement
Lambdas are strict. If you pass the wrong number of arguments, a Lambda will raise an ArgumentError. Procs are lenient; if you pass too many, they ignore the extras. If you pass too few, they assign nil to the missing ones.
my_proc = Proc.new { |x, y| puts "x: #{x}, y: #{y}" }
my_proc.call(1) # Output: x: 1, y:
my_lambda = ->(x, y) { puts "x: #{x}, y: #{y}" }
# my_lambda.call(1) # Raises ArgumentError: wrong number of arguments (given 1, expected 2)
Difference 2: Return Behavior
This is the most dangerous difference. A return inside a Lambda returns control to the calling method (like a normal function). A return inside a Proc returns from the scope where the Proc was defined, potentially ending the execution of the calling method entirely.
def proc_test
my_proc = Proc.new { return "Return from Proc" }
my_proc.call
"This line will NEVER be reached"
end
def lambda_test
my_lambda = -> { return "Return from Lambda" }
my_lambda.call
"This line WILL be reached"
end
puts proc_test # Output: Return from Proc
puts lambda_test # Output: This line WILL be reached
5. Real-World Example: Building a Data Filter
Let’s apply these concepts to a real-world scenario. Imagine you are building a system that filters a list of products based on various criteria like price and stock status.
class Product
attr_reader :name, :price, :stock
def initialize(name, price, stock)
@name = name
@price = price
@stock = stock
end
end
products = [
Product.new("Laptop", 1200, 5),
Product.new("Mouse", 25, 0),
Product.new("Keyboard", 75, 10)
]
# Defining our filters as Lambdas
price_filter = ->(product) { product.price < 100 }
stock_filter = ->(product) { product.stock > 0 }
# A method that accepts a list and a closure
def filter_products(list, filter_logic)
list.select { |p| filter_logic.call(p) }
end
# Usage
affordable_items = filter_products(products, price_filter)
in_stock_items = filter_products(products, stock_filter)
puts "Affordable items: #{affordable_items.map(&:name).join(', ')}"
# Output: Affordable items: Mouse, Keyboard
6. Step-by-Step: Converting a Block to a Proc
Sometimes you want to capture a block and save it for later within a method. You can do this by using the & operator in the method signature.
- Define the method with a named block: Add a parameter with an
&prefix at the end of the argument list. - The block becomes a Proc: Inside the method, the variable (without the
&) is now a Proc object. - Execute when needed: Call
.callon that object.
def delayed_execution(&my_block)
puts "Setting up..."
@stored_proc = my_block # Saving the block as a Proc
end
delayed_execution { puts "I was executed late!" }
# Later in the program...
@stored_proc.call # Output: I was executed late!
7. The “&” Operator and Symbols
You have likely seen code like [1, 2, 3].map(&:to_s). This is a shorthand that uses the & operator to convert a symbol into a Proc.
When you call &symbol, Ruby calls to_proc on that symbol. The resulting Proc calls the method named by the symbol on the object passed to it.
# These two are equivalent:
names = ["alice", "bob", "charlie"]
# Version 1: Standard block
names.map { |name| name.capitalize }
# Version 2: Symbol to Proc shorthand
names.map(&:capitalize)
8. Common Mistakes and How to Fix Them
Mistake 1: Unexpected Return in Procs
The Problem: Using return inside a Proc used in an iterator, causing the whole method to exit prematurely.
The Fix: Use next instead of return if you only want to exit the current iteration, or use a Lambda.
Mistake 2: Forgetting block_given?
The Problem: Your method crashes with LocalJumpError when someone calls it without a block.
The Fix: Always wrap yield in an if block_given? check or provide a default Proc.
Mistake 3: Overusing Procs for Simple Logic
The Problem: Making code harder to read by wrapping every small logic piece in a Proc.
The Fix: If the logic is only used once and is simple, use a standard block. Reserve Procs and Lambdas for when you need to store or pass the logic.
9. Advanced Concept: Binding and Closures
One of the most powerful aspects of blocks, procs, and lambdas is that they carry their Scope (Binding) with them. This means they remember the variables that were available when they were created.
def create_multiplier(factor)
->(number) { number * factor }
end
triple = create_multiplier(3)
quadruple = create_multiplier(4)
puts triple.call(10) # Output: 30
puts quadruple.call(10) # Output: 40
# Even though factor was a local variable in 'create_multiplier',
# the lambda remembers it!
10. Summary and Key Takeaways
Ruby closures are a cornerstone of the language’s flexibility. Here is a quick reference for your next project:
- Blocks: Not objects. Passed to methods. Used via
yield. Best for simple, one-off iterations. - Procs: Objects. Lenient with arguments.
returnexits the defining scope. Best for reusable snippets of code. - Lambdas: Objects. Strict with arguments.
returnexits only the lambda itself. Best for code that behaves like a method. - & Operator: Used to convert between blocks and Procs. Allows for the
&:method_nameshorthand. - Closures: All three capture the surrounding local variables, allowing for powerful functional programming patterns.
Frequently Asked Questions (FAQ)
1. Which is faster: a Block or a Proc?
Blocks are generally faster than Procs or Lambdas. Creating a Proc involves instantiating a new object in memory, whereas a block is a syntactic construct that Ruby handles more efficiently. For performance-critical loops, stick with blocks.
2. Can I pass multiple blocks to a single method?
Strictly speaking, a method can only take one block via the yield/&block syntax. However, you can pass as many Procs or Lambdas as you want as regular arguments.
3. What does “Stabby Lambda” mean?
“Stabby Lambda” refers to the ->() {} syntax introduced in Ruby 1.9. It is called “stabby” because the arrow looks like a small knife or spear. It is now the preferred way to write lambdas in modern Ruby.
4. Why does Ruby have both Procs and Lambdas?
It comes down to design philosophy. Lambdas are designed to behave like methods (strict and self-contained), while Procs are designed to behave like snippets of code pasted into the middle of another method (lenient and sharing the return path). Having both allows developers to choose the specific control flow they need.
5. How do I debug a block?
You can use standard debugging tools like binding.pry or byebug inside a block just as you would in a method. Because the block captures the surrounding scope, you will have access to all variables defined outside the block as well.