Lambda creation and behavior in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple lambda call

What is the output of this Ruby code?

Ruby

my_lambda = ->(x) { x * 3 }
puts my_lambda.call(4)

A 4

B 12

C Error: wrong number of arguments

D nil

💡 Hint

Remember that the lambda multiplies the input by 3.

The lambda takes one argument x and returns x multiplied by 3. Calling it with 4 returns 12.

❓ Predict Output

intermediate

Lambda argument count enforcement

What happens when this Ruby code runs?

Ruby

my_lambda = ->(x, y) { x + y }
puts my_lambda.call(5)

A 5 + nil (TypeError)

B 5

C nil

D Error: wrong number of arguments (given 1, expected 2)

💡 Hint

Lambdas check the number of arguments strictly.

The lambda expects 2 arguments but only 1 is given, so Ruby raises an ArgumentError.

❓ Predict Output

advanced

Difference between lambda and proc in argument handling

What is the output of this Ruby code?

Ruby

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

A

5
5

B

Error
Error

C

5
Error: wrong number of arguments (given 1, expected 2)

D

nil
Error

💡 Hint

Procs are lenient with arguments, lambdas are strict.

The proc treats missing arguments as nil and uses default 0, so 5 + 0 = 5. The lambda requires exactly 2 arguments and raises an error when only 1 is given.

🧠 Conceptual

advanced

Return behavior inside lambda vs proc

What happens when this Ruby code runs?

Ruby

def test_lambda
  l = -> { return "from lambda" }
  l.call
  "after lambda"
end

def test_proc
  p = Proc.new { return "from proc" }
  p.call
  "after proc"
end

puts test_lambda
puts test_proc

A

after lambda
from proc

B

after lambda
after proc

C

from lambda
after proc

D

from lambda
from proc

💡 Hint

Return inside a proc exits the method, return inside a lambda exits only the lambda.

The lambda's return exits only the lambda block, so the method continues and returns 'after lambda'. The proc's return exits the whole method immediately, returning 'from proc'.

🔧 Debug

expert

Why does this lambda raise an error?

This Ruby code raises an error. Which option explains the cause?

Ruby

my_lambda = ->(x) { x + y }
y = 10
puts my_lambda.call(5)

A NameError because y is not defined inside the lambda's scope at the time of call

B ArgumentError because lambda expects 2 arguments but only 1 given

C SyntaxError due to missing parentheses in lambda definition

D No error, outputs 15

💡 Hint

Check variable scope inside lambdas.

The variable y is defined after the lambda is created, but the lambda captures the environment at creation. Since y is not in scope inside the lambda when called, a NameError is raised.

Practice

1. What is a lambda in Ruby?

easy

A. A type of loop that repeats code multiple times

B. A special variable that holds numbers only

C. A method that automatically runs when a program starts

D. A small block of code stored in a variable that can be called later

Solution

1. Step 1: Understand what a lambda represents

   A lambda is a reusable piece of code stored in a variable, like a mini-function.

2. Step 2: Compare with other options

   Options A, C, and D describe loops, methods, or variables, not lambdas.

3. Final Answer:

   A small block of code stored in a variable that can be called later -> Option D

4. Quick Check:

   Lambda = reusable code block [OK]

Hint: Lambdas are like mini-functions stored in variables [OK]

Common Mistakes:

• Confusing lambdas with loops
• Thinking lambdas run automatically
• Believing lambdas hold only numbers

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

easy

A. ->(x) { x * 2 }

B. def lambda(x) x * 2 end

C. lambda(x) => x * 2

D. lambda(x) { x * 2 }

Solution

1. Step 1: Identify valid lambda syntax

   In Ruby, lambdas can be created using the arrow syntax ->(params) { code } or lambda { |params| code }.

2. Step 2: Check each option

   lambda(x) { x * 2 }: invalid syntax (lambda keyword expects block with |params|, not parenthesized args). def lambda(x) x * 2 end: method definition, not a lambda. lambda(x) => x * 2: invalid syntax. ->(x) { x * 2 }: correct arrow syntax.

3. Final Answer:

   ->(x) { x * 2 } -> Option A

4. Quick Check:

   Arrow syntax ->(x) { ... } creates lambda [OK]

Hint: Use ->(params) { code } or lambda { |params| code } [OK]

Common Mistakes:

• Using def instead of lambda
• Incorrect arrow syntax
• Confusing method and lambda syntax

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

my_lambda = ->(x) { x + 3 }
puts my_lambda.call(4)

medium

A. 3

B. 4

C. 7

D. Error

Solution

1. Step 1: Understand the lambda behavior

   The lambda adds 3 to the input number x.

2. Step 2: Calculate the output

   Calling my_lambda.call(4) computes 4 + 3 = 7.

3. Final Answer:

   7 -> Option C

4. Quick Check:

   4 + 3 = 7 [OK]

Hint: Call lambda with .call and input to get output [OK]

Common Mistakes:

• Forgetting to use .call to invoke lambda
• Confusing input and output values
• Expecting syntax error

4. What is wrong with this Ruby code?

my_lambda = lambda { |x, y| x + y }
puts my_lambda.call(5)

medium

A. It will raise an ArgumentError

B. It will print nil

C. It will print 5

D. It will raise a SyntaxError

Solution

1. Step 1: Check lambda argument requirements

   Lambdas check arguments strictly. This lambda expects 2 arguments (x and y).

2. Step 2: Analyze the call with one argument

   Calling my_lambda.call(5) provides only 1 argument, causing ArgumentError.

3. Final Answer:

   It will raise an ArgumentError -> Option A

4. Quick Check:

   Lambda argument count mismatch = ArgumentError [OK]

Hint: Lambdas need exact argument count or error [OK]

Common Mistakes:

• Assuming missing arguments default to nil
• Expecting no error on fewer arguments
• Confusing lambdas with procs (which are lenient)

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

def test_lambda
  l = -> { return "Inside lambda" }
  result = l.call
  return "Outside lambda"
end
puts test_lambda

hard

A. Inside lambda

B. Outside lambda

C. nil

D. Error

Solution

1. Step 1: Understand lambda return behavior

   Return inside a lambda exits only the lambda, not the enclosing method.

2. Step 2: Trace method execution

   The lambda returns "Inside lambda" to variable result, but method continues and returns "Outside lambda".

3. Final Answer:

   Outside lambda -> Option B

4. Quick Check:

   Lambda return exits lambda only, method returns after [OK]

Hint: Return inside lambda exits lambda, not method [OK]

Common Mistakes:

• Thinking return inside lambda exits method
• Expecting "Inside lambda" as output
• Confusing lambda with proc return behavior