Lambda and Proc - both are container for a block of code. Define a set of codes inside either of them and save them as a variable for later use.
Let's see the usage of both in detail
Lambda
A lambda is very similar to method, just the syntax varies. Below is the syntax for creation
test_lambda = -> { puts 'something'}
# lambda using arguments
test_lambda = -> (x) { x + 1}
Now we have defined a lambda and store in a variable test_lambda
, we have to call it to use. There are multiple ways to call a lambda. Below is the list of ways
test_lambda.call
test_lambda.call()
test_lambda.()
test_lambda.[]
test_lambda.[]
test_lambda.===
I prefer .call()
as it is more readable than others
If we call the defined lambda, the block of code is executed and result is displayed
test_lambda.call(5)
6
=> 6
As I stated earlier, lambda works very similar to methods if lambda is defined with args, the number of args should match during call, else it will raise an exception just like a regular method.
Also like a regular method a lambda will return normally to it's __callee__
rather than returning from a context
Example
def demo_lambda(num)
test_lambda = -> (x) { return x + 1 }
new_value = test_lambda.call(num)
puts 'new value returned'
new_value
end
Here the return of the test_lambda will return the value within the scope of the lambda (i.e returned value is stored in new_value
) and will proceed with the execution of below lines
Proc
Procs are similar to lambda, but there are few differnces and the choice to use between Proc and Lambda depends on it
Proc creation uses different syntax
test_proc = Proc.new {|x| x+1 }
Calling Proc is similar to lambda. It can be called using .call(), .(), .[], .===
Proc doesn't care about the number of arguments passed. But if the argument is used for any kind of calculation or manipulation it will raise an error.
Example
p = Proc.new{|x| puts 'something'}
p.call()
=> "Something"
p = Proc.new{|x| x*2 }
p.call()
(irb):61:in `block in <main>': undefined method `*' for nil:NilClass (NoMethodError)
p = Proc.new{|x| x*2 }
#since there is a calculation based on the args passed NilClass error is thrown
One more major difference is proc will return from the current context. i.e if proc is inside an method, then calling return from proc is equivalent to returning from that method. Let's see an example
def demo_proc(num)
test_proc = Proc.new{ |x| return x + 1 }
new_value = test_proc.call(num)
puts 'new value returned'
new_value
end
demo_proc(5)
irb(main):008:0> demo_proc(5)
=> 6
In the above sample, the puts statement will not be printed. This is because the return in test_proc will return from the demo_proc itself.
Top comments (0)