Sometimes when you use blocks you need to do something with the return value of a block. Using the last evaluated statement in the block can be hard to follow for others.

Consider the following trivial code. The actual scenario where I figured this out was much more complex and meaningful, of course.

def foo
  10.times do |n| # We don't want to 'next' to this loop. Simply to prove a point.
    puts "in loop #{n}"
    return bar do |from_bar| # We want to return from this method in the first loop.
      puts "got \"#{from_bar}\" from bar."
      next "foo done" # This code will be the block's return value but will *not* apply to the outer loop.
    end
  end
end

def bar
  puts "in bar"
  ret = yield "hello from bar"
  puts "back to bar land. got \"#{ret}\" from caller"
  return "bar, signing out"
end

puts "foo returns \"#{foo}\""

Here’s what you get when you run it:

in loop 0
in bar
got "hello from bar" from bar.
back to bar land. got "foo done" from caller
foo returns "bar, signing out"

This may be preferable to just putting your return value somewhere in the block whereit will evaluate last. If you’re building a complex block, first consider refactoring. If you can’t, you may want to use this ‘next’ trick. When you or someone works on the code later, they may not consider that the block must return a value, add some code at the end and completely throw off the intended return value.