Proc vs lambda differences (arity, return) in Ruby - Hands-On Comparison

Proc vs Lambda Differences (Arity, Return) in Ruby

📖 Scenario: Imagine you are learning how to use two similar tools in Ruby called Proc and lambda. Both can hold blocks of code to run later, but they behave differently when it comes to how many inputs they accept (arity) and how they handle the return statement.

🎯 Goal: You will create a Proc and a lambda that each take exactly one number, then try to return from inside them. You will see how they behave differently with input counts and return.

📋 What You'll Learn

Create a Proc named my_proc that takes one argument and returns double the value.

Create a lambda named my_lambda that takes one argument and returns double the value.

Call my_proc with two arguments and observe behavior.

Call my_lambda with two arguments and observe behavior.

Show how return works inside Proc and lambda.

💡 Why This Matters

🌍 Real World

Understanding Procs and lambdas helps you write flexible and clear Ruby code, especially when passing blocks or callbacks.

💼 Career

Many Ruby jobs require knowledge of blocks, Procs, and lambdas to write clean, maintainable code and handle functional programming patterns.

1

Create a Proc named my_proc that takes one argument and returns double the value

Create a Proc called my_proc that takes one argument x and returns x * 2.

Ruby

# Create a Proc named my_proc that doubles its input
# Your code here

Hint

Use Proc.new { |x| x * 2 } to create the Proc.

2

Create a lambda named my_lambda that takes one argument and returns double the value

Create a lambda called my_lambda that takes one argument x and returns x * 2.

Ruby

my_proc = Proc.new { |x| x * 2 }
# Create a lambda named my_lambda that doubles its input
# Your code here

Hint

Use my_lambda = ->(x) { x * 2 } to create the lambda.

3

Call my_proc with two arguments and observe behavior

Call my_proc with arguments 5 and 10 using my_proc.call(5, 10) and assign the result to proc_result.

Ruby

my_proc = Proc.new { |x| x * 2 }
my_lambda = ->(x) { x * 2 }
# Call my_proc with 5 and 10 and assign to proc_result
# Your code here

Hint

Use proc_result = my_proc.call(5, 10) to call the Proc with two arguments.

4

Call my_lambda with two arguments and observe behavior

Call my_lambda with arguments 5 and 10 using my_lambda.call(5, 10) inside a begin-rescue block to catch errors. Assign the error message to lambda_error if an error occurs.

Ruby

my_proc = Proc.new { |x| x * 2 }
my_lambda = ->(x) { x * 2 }
proc_result = my_proc.call(5, 10)
# Call my_lambda with 5 and 10 and catch errors, assign error message to lambda_error
# Your code here

Hint

Use a begin-rescue block to catch the ArgumentError when calling the lambda with wrong number of arguments.

5

Show how return works inside Proc and lambda

Create a method test_return that calls a Proc with a return inside and then prints 'After proc'. Then create a method test_lambda_return that calls a lambda with a return inside and then prints 'After lambda'. Call both methods and assign their outputs to proc_output and lambda_output respectively.

Ruby

my_proc = Proc.new { |x| x * 2 }
my_lambda = ->(x) { x * 2 }
proc_result = my_proc.call(5, 10)
begin
  my_lambda.call(5, 10)
rescue ArgumentError => e
  lambda_error = e.message
end
# Define test_return and test_lambda_return methods to show return behavior
# Your code here

Hint

Remember that return inside a Proc exits the whole method, but inside a lambda it only exits the lambda.

Practice

1. Which statement correctly describes the difference between a Proc and a lambda in Ruby regarding argument checking?

easy

A. Both Proc and lambda check arguments strictly.

B. Proc checks arguments strictly; lambda is lenient.

C. Neither Proc nor lambda check arguments.

D. Proc is lenient with arguments; lambda checks arguments strictly.

Solution

1. Step 1: Understand argument checking behavior

   A Proc in Ruby does not enforce the number of arguments strictly; it allows missing or extra arguments without error.

2. Step 2: Compare with lambda behavior

   A lambda behaves like a method and enforces the exact number of arguments, raising an error if the count is wrong.

3. Final Answer:

   Proc is lenient with arguments; lambda checks arguments strictly. -> Option D

4. Quick Check:

   Argument checking = Proc lenient, lambda strict [OK]

Hint: Remember: lambda acts like a method, Proc is more flexible [OK]

Common Mistakes:

• Thinking both check arguments strictly
• Confusing which one is strict
• Assuming Proc raises error on wrong args

2. Which of the following is the correct syntax to create a lambda in Ruby?

easy

A. lambda = Proc.new { |x| x * 2 }

B. lambda = proc { |x| x * 2 }

C. lambda = ->(x) { x * 2 }

D. lambda = lambda.new { |x| x * 2 }

Solution

1. Step 1: Identify lambda creation syntax

   In Ruby, lambdas can be created using the literal syntax ->(args) { block } or lambda { block }. The arrow syntax is common and concise.

2. Step 2: Check each option

   lambda = Proc.new { |x| x * 2 } creates a Proc, not a lambda. lambda = ->(x) { x * 2 } uses the correct lambda literal syntax. lambda = proc { |x| x * 2 } creates a Proc using proc. lambda = lambda.new { |x| x * 2 } is invalid syntax.

3. Final Answer:

   lambda = ->(x) { x * 2 } -> Option C

4. Quick Check:

   Lambda syntax = ->(args) { block } [OK]

Hint: Use ->(args) { } for lambda, Proc.new or proc for Proc [OK]

Common Mistakes:

• Using Proc.new when lambda is needed
• Trying lambda.new which doesn't exist
• Confusing proc and lambda syntax

3. What will be the output of the following Ruby code?

def test_proc
  p = Proc.new { return "From Proc" }
  p.call
  return "From method"
end

puts test_proc

medium

A. "From Proc"

B. "From method"

C. nil

D. RuntimeError

Solution

1. Step 1: Understand Proc return behavior

   When a Proc executes a return, it returns from the enclosing method, not just the Proc block.

2. Step 2: Trace the code execution

   Calling p.call triggers the Proc's return, which exits the test_proc method immediately with "From Proc". The later return "From method" is never reached.

3. Final Answer:

   "From Proc" -> Option A

4. Quick Check:

   Proc return exits method = "From Proc" [OK]

Hint: Proc return exits method; lambda return exits lambda only [OK]

Common Mistakes:

• Thinking return exits only the Proc block
• Expecting "From method" output
• Confusing Proc and lambda return behavior

4. Identify the error in the following Ruby code and fix it:

def test_lambda
  l = lambda { |x| return x * 2 }
  l.call
  return "Done"
end

puts test_lambda

medium

A. No error; output is "Done"

B. Error: lambda expects argument; fix by passing argument to l.call

C. SyntaxError: lambda block missing do/end

D. Error: lambda return exits method; fix by removing return inside lambda

Solution

1. Step 1: Check lambda argument requirements

   The lambda expects one argument x, but l.call is called without arguments, causing an ArgumentError.

2. Step 2: Fix the call by passing an argument

   Calling l.call(5) or any value fixes the error. The lambda returns x * 2, but this return exits only the lambda, so the method continues and returns "Done".

3. Final Answer:

   Error: lambda expects argument; fix by passing argument to l.call -> Option B

4. Quick Check:

   Lambda arity strict = pass correct args [OK]

Hint: Lambda needs exact args; always pass them when calling [OK]

Common Mistakes:

• Ignoring missing argument error
• Thinking lambda return exits method
• Assuming no arguments needed for lambda

5. Given the following code, what will be the output?

def test
  l = ->(x) { return x * 2 }
  p = Proc.new { return "Proc return" }
  result_l = l.call(3)
  result_p = p.call
  return "Method end"
end

puts test

hard

A. "Proc return"

B. "Method end"

C. 6

D. ArgumentError

Solution

1. Step 1: Execute lambda call

   The lambda l is called with argument 3, returns 6, but its return exits only the lambda, so method continues.

2. Step 2: Execute Proc call

   The Proc p is called next. Its return exits the entire method immediately with "Proc return". The later return "Method end" is never reached.

3. Final Answer:

   "Proc return" -> Option A

4. Quick Check:

   Proc return exits method, lambda return exits lambda [OK]

Hint: Proc return exits method immediately; lambda return does not [OK]

Common Mistakes:

• Expecting method to return "Method end"
• Confusing which return exits method
• Ignoring Proc's immediate method exit