Proc vs lambda differences (arity, return) in Ruby - Visual Side-by-Side Comparison

Concept Flow - Proc vs lambda differences (arity, return)

Define Proc or Lambda

↓

Call with arguments

↓

Check arity enforcement

↓

Raise error

↓

Execute block body

↓

Return behavior

↓

End

This flow shows how Proc and lambda differ in checking argument count and how return behaves inside them.

Execution Sample

Ruby

def demo
  my_lambda = ->(x) { return x * 2 }
  my_proc = Proc.new { |x| return x * 2 }

  puts my_lambda.call(3)
  puts my_proc.call(3)
end

demo

This code defines a lambda and a proc, each returning double the input, then calls and prints their results.

Execution Table

Step	Code Line	Action	Arity Check	Return Behavior	Output/Effect
1	my_lambda = ->(x) { return x * 2 }	Define lambda expecting 1 argument	Strict: expects exactly 1	Return exits lambda only	Lambda stored
2	my_proc = Proc.new { |x| return x * 2 }	Define proc accepting 1 argument	Lenient: accepts any number	Return exits enclosing method	Proc stored
3	puts my_lambda.call(3)	Call lambda with 3	3 matches 1 arg: OK	Return exits lambda, returns 6	Prints 6
4	puts my_proc.call(3)	Call proc with 3	No strict check, OK	Return exits method, ends method here	Prints 6, then method returns
5	After proc call	Code after proc call not reached	N/A	N/A	No output, program ends

💡 Proc's return exits the whole method, so code after proc call is not executed.

Variable Tracker

Variable	Start	After 1	After 2	Final
my_lambda	undefined	lambda object	lambda object	lambda object
my_proc	undefined	undefined	proc object	proc object
x (lambda)	undefined	undefined	3	3
x (proc)	undefined	undefined	3	3

Key Moments - 3 Insights

Why does the proc cause the method to exit early but the lambda does not?

Because in the execution_table row 4, the proc's return exits the entire method, while the lambda's return only exits the lambda block (row 3).

What happens if you call the lambda with wrong number of arguments?

The lambda enforces arity strictly (row 3), so calling with wrong arguments raises an error, unlike proc which is lenient (row 4).

Does the proc check how many arguments it receives?

No, as shown in row 4, proc accepts any number of arguments without error.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output when calling my_lambda.call(3)?

A 6

B Error due to wrong arity

C 3

D No output

💡 Hint

See execution_table row 3 Output/Effect column

At which step does the program stop executing due to proc's return?

A Step 3

B Step 4

C Step 5

D After Step 5

💡 Hint

Check execution_table row 4 and 5 for return behavior and program end

If you call my_lambda.call(2,3), what happens?

A Returns 4

B Ignores extra argument and returns 4

C Raises an argument error

D Returns nil

💡 Hint

Lambda enforces arity strictly as shown in execution_table row 3

Concept Snapshot

Proc vs Lambda in Ruby:
- Lambda checks exact number of arguments (arity), Proc does not.
- Lambda's return exits only the lambda block.
- Proc's return exits the entire method enclosing it.
- Use lambda when strict argument checking and local return needed.
- Use proc for flexible arguments and non-local return.

Full Transcript

This visual execution trace compares Ruby's Proc and lambda focusing on two key differences: arity checking and return behavior. The flow starts with defining a lambda and a proc, then calling each with one argument. The lambda enforces strict arity, so it expects exactly one argument and returns from the lambda block only. The proc is lenient with arguments and its return exits the whole method, ending execution early. The execution table shows each step, including argument checks and outputs. Variable tracking shows how arguments are passed. Key moments clarify why proc's return exits the method and lambda's does not, and how arity is enforced differently. The quiz tests understanding of output, program stopping point, and arity errors. The snapshot summarizes these differences for quick recall.

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