Returning inside for loop inside lambda crashes in Ruby 1.8

Question

In Ruby 1.8 (my version is 1.8.7-72), this code:

foo = lambda do
  for j in 1..2
    return
  end
end
foo.call

crashes with a LocalJumpError:

test2.rb:3: unexpected return (LocalJumpError)
    from test2.rb:2:in `each'
    from test2.rb:2
    from test2.rb:6:in `call'
    from test2.rb:6

Why does it do this? However, it seems to run fine on my version of Ruby 1.9.

Edit: it's not just the returning inside a lambda; the following runs fine:

foo = lambda do
  return
end
foo.call

Answer 1

What's happening is that the for statement in the middle of the lambda is converted internally into a block. In Ruby, return statements inside blocks are scoped to their enclosing method. Consider the following:

def bar
  foo = lambda do
    for j in 1..2
      return j
    end
  end
  foo[]
end
p bar

When running bar, 1 is returned, because the return is scoped to the entire bar method. To return from blocks, you want to use next or break, both of which take parameters. Consider:

def bar
  foo = lambda do
    for j in 1..2
      break j
    end
  end
  foo[] + 1
end
p bar

This break returns you from the block, and blocks any subsequent iterations. In this case, calling bar would return 2, since the iterator will return 1, and foo[] + 1 will therefore return 2.

If all of that sounded confusing, the main thing to realize is that return inside blocks is scoped to a surrounding method, and absent a surrounding method, a LocalJumpError is raised.

Answer 2

you can escape the loop and the rest of the lambda with a throw/catch

foo = lambda do 
        catch(:escape) do
          for j in 1..2
            throw :escape
          end
          # other code that won't get run
        end # catch(:escape)
      end # lambda

throw also takes an optional second paramter, which you can use to return a value.