Lambda creation and behavior in Ruby

Introduction

Lambdas let you create small pieces of reusable code that you can run later. They help keep your code neat and organized.

When you want to pass a small function as an argument to another method.

When you need a block of code that you can store and call multiple times.

When you want to create a quick function without naming it.

When you want to control how arguments are checked and how returns behave in a block of code.

Syntax

Ruby

my_lambda = ->(parameters) { code }
# or
my_lambda = lambda { |parameters| code }

The arrow syntax -> is a short way to create a lambda.

Lambdas check the number of arguments strictly and return control to the calling method when they finish.

Examples

This creates a lambda that says hello to a name and then calls it with "Alice".

Ruby

greet = ->(name) { puts "Hello, #{name}!" }
greet.call("Alice")

This lambda calculates the square of a number and prints 16.

Ruby

square = lambda { |x| x * x }
puts square.call(4)

This lambda adds two numbers and prints the result 8.

Ruby

adder = ->(a, b) { a + b }
result = adder.call(3, 5)
puts result

Sample Program

This program creates a lambda that greets a person by name. It shows how calling it without arguments causes an error because lambdas check arguments strictly. It also shows how a return inside a lambda only exits the lambda, not the whole method.

Ruby

say_hello = ->(name) { "Hello, #{name}!" }

puts say_hello.call("Bob")

# Showing argument check
begin
  say_hello.call
rescue ArgumentError => e
  puts "Error: #{e.message}"
end

# Showing return behavior
def test_lambda
  l = -> { return "Returned from lambda" }
  result = l.call
  return "Returned from method after lambda: #{result}"
end

puts test_lambda()

Important Notes

Lambdas are like methods inside variables.

They check the number of arguments strictly, unlike regular blocks.

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

Summary

Lambdas are small, reusable pieces of code you can store in variables.

They check arguments strictly and have special return behavior.

You create them using -> or lambda keywords.

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