6

In Ruby, I'd like to catch the NoMethodError generated on an object in another object, then return some value to where the exception is raised and continue execution. Is there an existing way to do this?

The best I came up with is:

class Exception
  attr_accessor :continuation
end

class Outer
  def hello
    puts "hello"
  end

  class Inner
    def world
      puts "world"
    end
    def method_missing(method, *args, &block)
      x = callcc do |cc|
        e = RuntimeError.exception(method)
        e.continuation = cc
        raise e
      end
      return x
    end
  end

  def inner(&block)
    inner = Inner.new
    begin
      inner.instance_eval(&block)
    rescue => e
      cc = e.continuation
      cc.call(hello())
    end
    inner
  end
end

o = Outer.new
o.inner do
  hello
  world
end

This prints

hello
world

Is there a better way to do this using Ruby's existing array of meta-programming arsenal? Basically, I am not sure if callcc will continue to exist.

Thanks.

Improve this question

2 Answers 2

Reset to default
6

What about this simple approach:

class Outer
  def hello
    puts "hello"
  end

  class Inner
    def initialize outer
      @outer = outer
    end

    def world
      puts "world"
    end

    def method_missing(method, *args, &block)
      @outer.send(method, *args, &block)
    rescue NoMethodError # you can also add this
      puts "#{method} is undefined in both inner and outer classes"
    end
  end

  def inner(&block)
    inner = Inner.new self
    inner.instance_eval(&block)
    inner
  end
end

o = Outer.new
o.inner do
  hello
  cruel
  world
end

Will print 

hello
cruel is undefined in both inner and outer classes
world

In this case if inner class does not define required method it delegate it to the outer class using Object#send. You can catch NoMethodError inside method_missing in order to control situation when Outer class does not define delegated method.

UPDATE You can also use fibers to solve the problem:

class Outer
    def hello
        puts "hello"
    end

    class Inner
        def world
            puts "world"
        end

        def method_missing(method, *args, &block)
            Fiber.yield [method, args, block] # pass method args to outer
        end
    end

    def inner(&block)
        inner = Inner.new
        f = Fiber.new { inner.instance_eval(&block) }
        result = nil # result for first fiber call does not matter, it will be ignored
        while (undef_method = f.resume result) # pass method execution result to inner
            result = self.send(undef_method[0], *undef_method[1], &undef_method[2])
        end
        inner
    end
end
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Alex - I like your first simple solution, although I am not sure it's better over the exception continuation approach. Tt's not worse, just different tradeoffs. E.g. now your inner has to be tied in with outer, so you cannot use some generic class instead of Inner when doing nesting. But your solution does avoid using callcc. I am looking for someone to tell me if callcc approach is going to be problematic because callcc may not (or may) continue to exist. Thanks.
@Overclocked, As Matz (Ruby creator) points out in his The Ruby Programming Language book, Because they are no longer well supported, continuations should be considered a curiosity, and new Ruby code should not use them. You are right that their usage is problematic. If you really don't want to tightly couple with outer class, then you can use Fibers from my second example to transfer control in and out of your inner class.
Alex - thanks for the note. I was looking for something like that on continuations. Too bad; continuations are great. But your fibers example is a good replacement. Thanks.
3

Ruby has a keyword called throw that can be used to propagate errors upward. I can't really tell from your post which block you would want this in but it goes something like this:

class Outer
  catch :NoMethodError do
  #process the exception thrown from inner
  end

  class Inner
    def some_method
      ##...some other processing
      throw :NoMethodError if #....
      #remaining statements
    end
  end
end

After the throw statement and catch block execute the remaining statements in some_method should execute

Hope this helps

Improve this answer

6 Comments

I am looking for some mechanism where I can return a value to where the "throw" occurred, and continue the execution. Is there a way to do that within something built-in like throw?
I'm not sure how you would return a value back, it may be possible, I just don't know of a way. You could create another instance variable for the Inner class and update it from the outer class; that may be a way of doing it.
@Overclocked What would the "where" look like?
@Phrogz - in my question, at the bottom, I called hello and world. The call to hello would not work when evaluated in Inner, since Inner#hello does not exist. But I want to evaluate Outer#hello in there instead. I don't want Inner to subclass Outer, so I need to catch the missing method exception from Inner, evaluate Outer#hello, return the result to the block, and continue to execute Inner#world.
Just want to note that in the example I think you confuse how throw/cache works in ruby. catch takes a "tag" and a block to executes and if something throw during execution of the block it will search upwards the stack to the first catch with the corresponding tag and continue executing after the catch statement.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.