Proc vs lambda differences (arity, return) in Ruby - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output difference: Proc vs Lambda with arity mismatch

What is the output of this Ruby code?

Ruby

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

puts my_proc.call
puts my_lambda.call

A

Value: 
ArgumentError: wrong number of arguments (given 0, expected 1)

B

ArgumentError: wrong number of arguments (given 0, expected 1)
Value: 

C

Value: 
Value: 

D

ArgumentError: wrong number of arguments (given 0, expected 1)
ArgumentError: wrong number of arguments (given 0, expected 1)

💡 Hint

Consider how Proc and lambda handle missing arguments differently.

Procs are lenient with arguments and assign nil if missing, so my_proc.call outputs "Value: ". Lambdas enforce arity strictly, so my_lambda.call raises an ArgumentError.

❓ Predict Output

intermediate

Return behavior difference between Proc and Lambda

What will be printed when running this Ruby code?

Ruby

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

def test_lambda
  l = -> { return "From Lambda" }
  l.call
  return "From method"
end

puts test_proc
puts test_lambda

A

From Proc
From Lambda

B

From method
From Lambda

C

From Proc
From method

D

From method
From method

💡 Hint

Think about how return works inside a Proc versus a lambda inside a method.

A return inside a Proc exits the enclosing method immediately, so test_proc returns "From Proc". A return inside a lambda only exits the lambda, so test_lambda continues and returns "From method".

🔧 Debug

advanced

Why does this lambda raise an error but the proc does not?

Consider this Ruby code snippet. Which option correctly explains why the lambda raises an error but the proc does not?

Ruby

my_proc = Proc.new { |a, b| a + (b || 0) }
my_lambda = ->(a, b) { a + b }

puts my_proc.call(5)
puts my_lambda.call(5)

A The lambda enforces the number of arguments strictly, so calling with one argument raises ArgumentError; the proc allows missing arguments and assigns nil.

B The proc enforces the number of arguments strictly, so calling with one argument raises ArgumentError; the lambda allows missing arguments and assigns nil.

C Both proc and lambda allow missing arguments, but the lambda raises an error because of the addition operation.

D Both proc and lambda raise ArgumentError because of missing arguments.

💡 Hint

Recall how procs and lambdas handle arity differently.

Lambdas check the number of arguments strictly and raise an error if the count doesn't match. Procs are lenient and assign nil to missing arguments, so my_proc.call(5) works but my_lambda.call(5) raises ArgumentError.

❓ Predict Output

advanced

Return inside Proc vs Lambda in nested method calls

What is the output of this Ruby code?

Ruby

def outer
  p = Proc.new { return "Proc return" }
  l = -> { return "Lambda return" }
  result_p = p.call
  result_l = l.call
  "Outer method end"
end

puts outer

A RuntimeError: unexpected return

B Proc return

C Outer method end

D Lambda return

💡 Hint

Think about what happens when return is called inside a Proc inside a method.

The return inside the Proc exits the entire outer method immediately, so outer returns "Proc return". The lambda's return is never reached.

🧠 Conceptual

expert

Which statement about Proc and Lambda is true?

Select the only true statement about Ruby Proc and Lambda behavior.

A Both Proc and Lambda enforce the exact number of arguments passed when called.

B A return inside a Proc exits only the Proc, while a return inside a Lambda exits the enclosing method.

C Procs and Lambdas behave identically in terms of arity and return behavior.

D A Lambda checks the number of arguments strictly and a return inside it exits only the Lambda, not the enclosing method.

💡 Hint

Recall the key differences in arity and return behavior between Proc and Lambda.

Lambdas enforce arity strictly and a return inside a lambda exits only the lambda itself. Procs are lenient with arguments and a return inside a proc exits the enclosing method.