Ruby - lambda vs. Proc.new [duplicate]

Question

Possible Duplicate:
What's the difference between a proc and a lambda in Ruby?

When run this Ruby code:

def func_one
    proc_new = Proc.new {return "123"}
    proc_new.call
    return "456"
end

def func_two
    lambda_new = lambda {return "123"}
    lambda_new.call
    return "456"
end

puts "The result of running func_one is " + func_one
puts ""
puts "The result of running func_two is " + func_two

The result that I get is as follows:

The result of running func_one is 123

The result of running func_two is 456

As for func_two, where is the the value of the first return, that is, 123?

Thanks.

Quass

Duplicate of What's the difference between a proc and a lambda in Ruby?; see also Differences between Proc and Lambda in Ruby. – Rixdollar

@Phrogz. Please check my question and the question in the thread you pointed to and see that my question is not a duplicate – Quass

I suppose that's a matter of opinion. You didn't ask the exact same question, but if you read the answer to that question you would have known the answer to your question. – Rixdollar

Also see Control flow differences between Ruby Procs and Lambdas – Selfstarter

The more detailed answer is really here: #1126 – Antetype

I'm wondering if there's any compelling reason to use Procs over lambdas? They behave pretty weird, not what you would expect from anonymous functions. – Sinistrad

Answer 1

This is one of the main differences between Procs and lambdas.

A return in a Proc returns from its enclosing block/method, while a return in a lambda simply returns from the lambda. When you call the lambda inside the func_two, it simply returns its value in place, which is not saved.

Read on Procs v. lambdas here: http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls

See duplicate SO question: Why does explicit return make a difference in a Proc?

EDIT:

To further illustrate this difference, swap func_one and func_two for blocks and see what happens:

> begin; lambda { return 1 }.call end
1
> begin; Proc.new { return 1 }.call end
LocalJumpError: unexpected return
...

Mosul

Answer 2

In the proc, the return "123" is bubbling up and returning from the outer function, func_one. Therefore the second return statement is never encountered.

In the lambda, the return "123" is returning only from the lambda. You're not setting an variable to the return value of the lambda (when you do lambda_new.call, so the value is basically just thrown out. Then, the return "456" is called and returns from the function. If, instead of returning "456", you returned lambda_new.call, the return value of func_two would be "123".

Coy

Answer 3

123 is a value of lambda_new.call statement, but it is not used and not shows up.

Recollect

What do you mean "it is not used"? Your answer is not very clear. – Circe