Codecademy Logo

Blocks, Procs, and Lambdas

Print Cheatsheet

Ruby .call Method

In Ruby, a proc and a lambda can be called directly using the .call method.

proc_test = Proc.new { puts "I am the proc method!" }
lambda_test = lambda { puts "I am the lambda method!"}
proc_test.call # => I am the proc method!
lambda_test.call # => I am the lambda method!
#The following code would result in "I am the proc method!" and "I am the lambda method!" printed to the console respectively, once the proc, proc_test, and the lambda, lambda_test, are called.

Ruby lambda

In Ruby, a lambda is an object similar to a proc. Unlike a proc, a lambda requires a specific number of arguments passed to it, and it returns to its calling method rather than returning immediately.

def proc_demo_method
proc_demo = Proc.new { return "Only I print!" }
proc_demo.call
"But what about me?" # Never reached
end
puts proc_demo_method
# Output
# Only I print!
# (Notice that the proc breaks out of the method when it returns the value.)
def lambda_demo_method
lambda_demo = lambda { return "Will I print?" }
lambda_demo.call
"Sorry - it's me that's printed."
end
puts lambda_demo_method
# Output
# Sorry - it's me that's printed.
# (Notice that the lambda returns back to the method in order to complete it.)

Ruby .collect Method

In Ruby, the .collect array method takes a block and applies the expression in the block to every element of an array.

first_arr = [3, 4, 5]
second_arr = first_arr.collect { |num| num * 5 }
print second_arr #Output => [15, 20, 25]
# In this example, the .collect method is used to multiply each number within first_arr by 5. The outcome is then saved inside of the second_arr variable and printed to the console. The original first_arr is left unchanged.

Ruby yield Keyword

In Ruby, the yield keyword is used to transfer control from a method to a block and then back to the method once executed.

def yield_test
puts "I'm inside the method."
yield
puts "I'm also inside the method."
end
yield_test { puts ">>> I'm butting into the method!" }
#Output
# I'm inside the method.
# >>> I'm butting into the method.
# I'm also inside the method.

Ruby proc

In Ruby, a proc is an instance of the Proc class and is similar to a block. As opposed to a block, a proc is a Ruby object which can be stored in a variable and therefore reused many times throughout a program.

square = Proc.new { |x| x ** 2 }
# A proc is defined by calling Proc.new followed by a block.
[2, 4, 6].collect!(&square)
# When passing a proc to a method, an & is used to convert the proc into a block.
puts [2, 4, 6].collect!(&square)
# => [4, 16, 36]