Ruby Blocks, Procs, and Lambdas

Master Ruby's functional programming features with blocks, procs, and lambdas. These are fundamental to Ruby's expressive and elegant style.

Blocks

Basic Block Syntax

Block with do...end (multi-line)

[1, 2, 3].each do |num| puts num * 2 end

Block with {...} (single line)

[1, 2, 3].each { |num| puts num * 2 }

Yielding to Blocks

def repeat(times) times.times do yield # Execute the block end end

repeat(3) { puts "Hello" }

With block parameters

def greet yield("World") end

greet { |name| puts "Hello, #{name}!" }

Block Arguments

def process_data(data) result = yield(data) puts "Result: #{result}" end

process_data(10) { |x| x * 2 } # Result: 20

Checking for Blocks

def optional_block if block_given? yield else puts "No block provided" end end

optional_block { puts "Block executed" } optional_block

Block Local Variables

x = 10

[1, 2, 3].each do |num; local_var| local_var = num * 2 # local_var only exists in block puts local_var end

puts x # 10 (unchanged)

Procs

Creating Procs

Using Proc.new

my_proc = Proc.new { |x| x * 2 } puts my_proc.call(5) # 10

Using proc method (deprecated in some versions)

my_proc = proc { |x| x * 2 }

Using -> (stabby lambda syntax for Proc)

my_proc = ->(x) { x * 2 }

Proc Characteristics

Procs don't care about argument count

flexible_proc = Proc.new { |x, y| "x: #{x}, y: #{y}" } puts flexible_proc.call(1) # x: 1, y: puts flexible_proc.call(1, 2, 3) # x: 1, y: 2 (ignores extra)

Procs return from the enclosing method

def proc_return my_proc = Proc.new { return "from proc" } my_proc.call "after proc" # Never reached end

puts proc_return # "from proc"

Passing Procs as Arguments

def execute_proc(my_proc) my_proc.call end

greeting = Proc.new { puts "Hello from proc!" } execute_proc(greeting)

Converting Blocks to Procs

def method_with_proc(&block) block.call end

method_with_proc { puts "Block converted to proc" }

Lambdas

Creating Lambdas

Using lambda keyword

my_lambda = lambda { |x| x * 2 }

Using -> (stabby lambda)

my_lambda = ->(x) { x * 2 }

Multi-line stabby lambda

my_lambda = ->(x) do result = x * 2 result + 1 end

puts my_lambda.call(5) # 11

Lambda Characteristics

Lambdas enforce argument count

strict_lambda = ->(x, y) { x + y }

strict_lambda.call(1) # ArgumentError

strict_lambda.call(1, 2) # Works

Lambdas return to the caller

def lambda_return my_lambda = -> { return "from lambda" } my_lambda.call "after lambda" # This IS reached end

puts lambda_return # "after lambda"

Lambda with Multiple Arguments

add = ->(x, y) { x + y } multiply = ->(x, y, z) { x * y * z }

puts add.call(3, 4) # 7 puts multiply.call(2, 3, 4) # 24

Default arguments

greet = ->(name = "World") { "Hello, #{name}!" } puts greet.call # "Hello, World!" puts greet.call("Ruby") # "Hello, Ruby!"

Proc vs Lambda

Argument handling

my_proc = Proc.new { |x, y| puts "x: #{x}, y: #{y}" } my_lambda = ->(x, y) { puts "x: #{x}, y: #{y}" }

my_proc.call(1) # Works: x: 1, y:

my_lambda.call(1) # ArgumentError

Return behavior

def test_return proc_test = Proc.new { return "proc return" } lambda_test = -> { return "lambda return" }

proc_test.call # Returns from method "end" # Never reached end

def test_lambda lambda_test = -> { return "lambda return" } lambda_test.call # Returns from lambda "end" # This IS reached end

Check if it's a lambda

my_proc = Proc.new { } my_lambda = -> { }

puts my_proc.lambda? # false puts my_lambda.lambda? # true

Closures

def multiplier(factor) ->(x) { x * factor } end

times_two = multiplier(2) times_three = multiplier(3)

puts times_two.call(5) # 10 puts times_three.call(5) # 15

Closures capture variables

def counter count = 0

increment = -> { count += 1 } decrement = -> { count -= 1 } value = -> { count }

[increment, decrement, value] end

inc, dec, val = counter inc.call inc.call puts val.call # 2 dec.call puts val.call # 1

Method Objects

class Calculator def add(x, y) x + y end end

calc = Calculator.new add_method = calc.method(:add) puts add_method.call(3, 4) # 7

Converting methods to procs

add_proc = calc.method(:add).to_proc puts add_proc.call(5, 6) # 11

Symbol to Proc

& converts symbol to proc

numbers = [1, 2, 3, 4, 5]

These are equivalent:

numbers.map { |n| n.to_s } numbers.map(&:to_s)

Works with any method

["hello", "world"].map(&:upcase) # ["HELLO", "WORLD"] [1, 2, 3].select(&:even?) # [2]

Higher-Order Functions

def compose(f, g) ->(x) { f.call(g.call(x)) } end

double = ->(x) { x * 2 } square = ->(x) { x * x }

double_then_square = compose(square, double) puts double_then_square.call(3) # 36 (3 * 2 = 6, 6 * 6 = 36)

Currying

Manual currying

add = ->(x) { ->(y) { x + y } } add_five = add.call(5) puts add_five.call(3) # 8

Built-in currying

multiply = ->(x, y, z) { x * y * z } curried = multiply.curry times_two = curried.call(2) times_two_three = times_two.call(3) puts times_two_three.call(4) # 24

Partial application

puts curried.call(2, 3).call(4) # 24

Practical Patterns

Lazy Evaluation

def lazy_value puts "Computing expensive value..." 42 end

Wrap in lambda for lazy evaluation

lazy = -> { lazy_value }

puts "Before call" result = lazy.call # Only computed here puts result

Callback Pattern

class Button def initialize @on_click = [] end

def on_click(&block) @on_click << block end

def click @on_click.each(&:call) end end

button = Button.new button.on_click { puts "Button clicked!" } button.on_click { puts "Another handler" } button.click

Strategy Pattern

class Sorter def initialize(strategy) @strategy = strategy end

def sort(array) @strategy.call(array) end end

ascending = ->(arr) { arr.sort } descending = ->(arr) { arr.sort.reverse }

sorter = Sorter.new(ascending) puts sorter.sort([3, 1, 2]) # [1, 2, 3]

sorter = Sorter.new(descending) puts sorter.sort([3, 1, 2]) # [3, 2, 1]

Memoization

def memoize(&block) cache = {} ->(arg) do cache[arg] ||= block.call(arg) end end

expensive_operation = memoize do |n| puts "Computing for #{n}..." n * n end

puts expensive_operation.call(5) # Computing for 5... 25 puts expensive_operation.call(5) # 25 (cached)

Best Practices

• Use blocks for simple iteration and single-use closures

• Use lambdas for strict argument checking and returnable closures

• Use procs for flexible argument handling (rare cases)

• Prefer -> syntax for lambdas (more concise)

• Use &:symbol for simple method calls on collections

• Leverage closures for encapsulation and data privacy

• Use block_given? before yielding to optional blocks

Anti-Patterns

❌ Don't use Proc.new for strict behavior - use lambda instead ❌ Don't ignore return behavior - understand proc vs lambda differences ❌ Don't overuse closures - can lead to memory leaks if not careful ❌ Don't create deeply nested lambdas - hard to read and debug ❌ Don't forget to handle missing blocks - check with block_given?

Related Skills

• ruby-oop - For understanding method context

• ruby-metaprogramming - For dynamic block/proc usage

• ruby-standard-library - For Enumerable methods using blocks