Everyone's favorite flow control: retry

Today I was thinking about retry support in JRuby, and figured we’ve
reached a decision point.

retry is a tricky little bugger. It works the way it does in MRI largely
because of the way the interpreter works; so in that sense it’s very
implementation specific. So here’s some example code, see if you can
figure out what it prints.

$count = 0
class Foo
def initialize
$count += 1
@value = $count

def do_retry(i)
puts “value is #{@value} and i is #{i}”

a = 0
Foo.new.do_retry(a += 1) {}

Give up? Here’s the answer:

value is 1 and i is 1
value is 2 and i is 2
value is 3 and i is 3

The trick here is the retry. A retry can only be used in a rescue block
(which is ok), inside a block, or inside a method that’s been passed a
block. Excluding rescue, retry causes the original call to the method
with the block to reevaluate. And I don’t just mean re-execute with the
same values, I mean re-evaluate both the receiver and the arguments and
make the call again.

So for example, this method invocation

def foo(a); puts 3; retry; end

(print 1; self).foo((print 2; nil)) {}

Prints out “123” forever, because the receiver (the (print 1; self) bit)
and the arguments (the (print 2; nil) bit) get executed again. Goofy,

This also affects retry within a block

def foo(a); puts 3; yield; end

(print 1; self).foo((print 2; nil)) { retry }

This also prints “123” repeatedly.

The problem I’ve run into is that it’s really cumbersome to implement
this correctly in the compiler, cumbersome enough I’m debating whether
we’ll support it. There’s a few reasons for this:

  • retry is handled using exception; so every method call that takes a
    block would have to be wrapped with exception-handling for retry to
    work. Exception-handling is expensive, even if no exceptions are
    actually raised. It would also add a significant amount of code.
  • there’s no way to know that a method will be reevaluated by looking at
    it, which makes it both dangerous and impossible to predict.
  • nobody understands retry, and nobody uses it.

As I understand it, retry in a method body is going away in 1.9, so it
should be considered deprecated behavior. So far, retry in a block is
not yet going away, though I’d prefer it did. Actually, I wish this
behavior never existed, because it makes a lot of assumptions about the
way Ruby is implemented. Ask if you want to know more about that.

I’m looking for input on this. If there’s a way to implement it I have
missed, please tell me. If you have a concern with this feature being
disabled, please tell me (it won’t affect retry within rescue blocks).
If you want to talk about it more, please tell me.

  • Charlie

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs