proc-object

Is it possible to convert a proc-flavored Proc into a lambda-flavored Proc? Bit surprised that this doesn't work, at least in 1.9.2: my_proc = proc {|x| x} my_lambda = lambda &p my_lambda.lambda? # => false! This one was a bit tricky to track down. Looking at the docs for Proc#lambda? for 1.9 , there's a fairly lengthy discussion about the difference between proc s and lamdba s. What it comes down to is that a lambda enforces the correct number of arguments, and a proc doesn't. And from that documentation, about the only way to convert a proc into a lambda is shown in this example: define

In Ruby, are there any differences between Proc.new { 'waffles' } and proc { 'waffles' } ? I have found very few mentions of the second syntax. From testing using irb , I haven't found any obvious differences. Is the second syntactic sugar for the first? From Metaprogamming Ruby Page 113. In Ruby 1.8, Kernel#proc() is actually a synonym for Kernel#lambda(). Because of loud protest from programmers, Ruby 1.9 made proc() a synonym for Proc.new() instead. 来源： https://stackoverflow.com/questions/4710538/ruby-proc-new-waffles-vs-proc-waffles

def foo f = Proc.new { return "return from foo from inside proc" } f.call # control leaves foo here return "return from foo" end def bar b = Proc.new { "return from bar from inside proc" } b.call # control leaves bar here return "return from bar" end puts foo # prints "return from foo from inside proc" puts bar # prints "return from bar" I thought the return keyword was optional in Ruby and that you are always return ing whether you request it or not. Given that, I find it surprising that foo and bar have different output determined by the fact that foo contains an explicit return in Proc f .

I'm trying to use Ruby 1.9.1 for an embedded scripting language, so that "end-user" code gets written in a Ruby block. One issue with this is that I'd like the users to be able to use the 'return' keyword in the blocks, so they don't need to worry about implicit return values. With this in mind, this is the kind of thing I'd like to be able to do: def thing(*args, &block) value = block.call puts "value=#{value}" end thing { return 6 * 7 } If I use 'return' in the above example, I get a LocalJumpError. I'm aware that this is because the block in question is a Proc and not a lambda. The code

An answer to a question I posed yesterday on here was the following piece of Ruby code: def overlap?(r1,r2) r1.include?(r2.begin) || r2.include?(r1.begin) end def any_overlap?(ranges) ranges.sort_by(&:begin).each_cons(2).any? do |r1,r2| overlap?(r1, r2) end end I get each_cons , but what's the strange &:begin notation? Save me from syntax hell! Thanks! When you prefix the last argument of a call with & you are making clear that you are sending a block and not a normal argument. Ok, in method(&:something) , :something is a symbol, not a proc , so Ruby automatically calls the method to_proc to