Proc creation and call in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a Proc call with arguments

What is the output of this Ruby code when the proc is called?

Ruby

my_proc = Proc.new { |x, y| x * y }
result = my_proc.call(3, 4)
puts result

A nil

B 12

C 7

D Error: wrong number of arguments

💡 Hint

Remember that Proc.new creates a block that can take arguments and returns the last expression.

The proc multiplies the two arguments 3 and 4, so the output is 12.

❓ Predict Output

intermediate

Proc with missing arguments

What happens when this proc is called with fewer arguments than expected?

Ruby

my_proc = Proc.new { |x, y| x + (y || 0) }
puts my_proc.call(5)

A 5

B Error: wrong number of arguments

C nil

D 0

💡 Hint

Procs allow missing arguments and assign nil if not provided.

The proc adds x and y, but y is nil so (y || 0) becomes 0, resulting in 5.

❓ Predict Output

advanced

Difference between Proc and lambda call behavior

What is the output of this code?

Ruby

my_lambda = ->(x, y) { x / y }
my_proc = Proc.new { |x, y| x / y }
puts my_lambda.call(10, 0)
puts my_proc.call(10, 0)

A ZeroDivisionError on lambda call, no output on proc call

B ZeroDivisionError on lambda call, Infinity on proc call

C ZeroDivisionError on lambda call, nil on proc call

D ZeroDivisionError on lambda call, ZeroDivisionError on proc call

💡 Hint

Both lambda and proc execute the division, which raises an error when dividing by zero.

Both calls raise ZeroDivisionError because dividing by zero is not allowed in Ruby.

❓ Predict Output

advanced

Return behavior inside Proc vs lambda

What is the output of this Ruby code?

Ruby

def test_return
  my_proc = Proc.new { return 'proc return' }
  my_lambda = -> { return 'lambda return' }
  result_proc = my_proc.call
  result_lambda = my_lambda.call
  'method end'
end
puts test_return

A proc return

B method end

C lambda return

D Error: unexpected return

💡 Hint

A return inside a proc returns from the enclosing method, but a return inside a lambda returns from the lambda only.

The proc's return exits the method immediately with 'proc return', so 'method end' is never reached.

🧠 Conceptual

expert

Which option causes a LocalJumpError?

Which of these code snippets will raise a LocalJumpError when executed?

A

def method
  my_proc = Proc.new { return 5 }
  my_proc.call
  10
end
puts method

B

my_lambda = -> { return 5 }
my_lambda.call

C

my_proc = Proc.new { return 5 }
my_proc.call

D

def method
  my_lambda = -> { return 5 }
  my_lambda.call
  10
end
puts method

💡 Hint

A return inside a proc called outside a method context causes LocalJumpError.

Calling a proc with return outside a method causes LocalJumpError because there's no method to return from.