Question

I decided to experiment with defining methods inside methods in Ruby and wrote this:

def foo
  def bar
    puts "hello"
  end
  bar
end

This defined, I ran foo and “hello” was printed as I expected. However I then tried foo.bar – which printed out “hello” twice. Why?

Answer 1

foo.bar equals foo().bar() so you call first foo which contains bar so it is executed once here, then bar is executed one more time. At the end bar is called twice.

def foo
  puts 'foo called'
  def bar
    puts 'bar called'
    puts "hello"
  end
  bar
end
foo.bar
#=> foo called
#=> bar called
#=> hello
#=> bar called
#=> hello

What I don’t understand is this means the result of foo which is nil can call bar.

>> nil.bar
#=> hello

How is that possible ?

Edit: As explained in some answers, nested method are included in the class scope so weither bar is declared inside or outside foo does not make any difference.

Also Matz said that it may change from Ruby2.0

here is the example he wrote:

class Foo
  def foo
    def bar
      #omited
    end
    bar # can be called
  end

  def quux
    bar # cannot be called
  end
end

edit-Ruby2.0: It finally did not get implemented. So it remains the same.