Ruby method scope?

Question

In the following example:

Main.rb

def main
  obj = ExampleClass.new
  def multiply(a, b, c, d)
    return a * b * c * d
  end
  puts obj.multiply(1, 2, 3, 4) # this prints 24
end
main

ExampleClass.rb

class ExampleClass
  def initialize

  end
end

Why is the multiply method now part of the obj instance? (the main method is not part of the ExampleClass definition)

https://stackoverflow.com/questions/917811/what-is-main-in-ruby nice concise (high level) explanation of how this works — engineersmnky, Jul 17 '17 at 19:26

Radix · Accepted Answer · 2017-07-17T21:17:28.127

3

The code written without additional class .. end, module .. end enclosures is executed directly, step by step, in context of special main object. This object can be referenced using:

2.2.2 :001 > self
# => main

Methods defined without additional classes/modules are defined as private methods of the main object, and, consequently, as private methods of almost any other object in Ruby:

2.2.2 :002 > def foo
2.2.2 :003?>   42
2.2.2 :004?> end
# => :foo 
2.2.2 :005 > foo
# => 42 
2.2.2 :006 > [].foo
# => NoMethodError: private method `foo' called for []:Array
2.2.2 :007 > [].send :foo
# => 42

Thus, in your code, main method (or it can any other method) is in the context of main object and so multiply method can be called from either ExampleClass.new or Array.new or from any other class.

Source: Wikipedia

UPDATE

Few notes from engineersmnky's comment.

This is not a private method in main but rather a private method of BasicObject (in 2.0-2.2).
As of 2.3 (and in 1.9.3) this method is not even privatized.
It need not be an instance of the class e.g. Class.new as the class itself will also have this method defined e.g. BasicObject.foo

edited Jul 17 '17 at 21:17

answered Jul 17 '17 at 19:09

Radix

2,527
1
19
43

The main method was not wrapped in the ExampleClass. – aoiee Jul 17 '17 at 19:14
What is `ExampleClass` then? Provide some code of `ExampleClass`. – Radix Jul 17 '17 at 19:15
`ExampleClass` is an empty class, I added it in. – aoiee Jul 17 '17 at 19:19
@aoiee Updated the answer. Hope it helps. – Radix Jul 17 '17 at 20:21
A few notes 1) this is not a private method in `main` but rather a private method of `BasicObject` (in 2.0-2.2). 2) As of 2.3 (and in 1.9.3) this method is not even privatized. 3) It need not be an instance of the class e.g. `Class.new` as the class itself will also have this method defined e.g. `BasicObject.foo` – engineersmnky Jul 17 '17 at 20:47

rodsoars · Answer 2 · 2017-07-17T19:17:31.823

2

Maybe it's because both the variable obj and the context where the method multiply was defined have Object as parent/ancestor.

If you call obj.class you will get ExampleClass < Object. Supposing you are in the console, if you call self.class, you will get Object < BasicObject. So, in your code, you have defined a method multiply for Object class. That's why multiply is part of obj instance.

edited Jul 17 '17 at 19:17

answered Jul 17 '17 at 19:07

rodsoars

401
8
16

Sort of...methods defined in `main` (not the method defined by the OP but the `Object` `main`) are automagically added as instance methods of `BasicObject` since every object inherits, directly or indirectly, from `BasicObject` this method is available everywhere as long as the receiving object does not define an object specific version of the method (nor do any ancestors all the way up to `BasicObject`) – engineersmnky Jul 17 '17 at 19:31
Methods defined at the top-level become `private` instance methods of `Object`, not `BasicObject`. – Jörg W Mittag Jul 29 '17 at 11:21

score 2 · Answer 3 · answered Jul 29 '17 at 11:20

Methods defined at script scope become private instance methods of Object. (Except in IRb, where they become public instance methods of Object.)

So, main is a private instance method of Object.

Method definitions inside methods do not create nested methods, i.e. multiply is not nested in main. Rather, each time you call main, you will create a new method called multiply as an instance method of Object. And for some reason that is not quite clear to me, it ends up as a public method.

So, what happens is the following:

you define main as a private instance method of Object
you call main, which will in turn define multiply as a public instance method of Object
you call multiply, which works because obj is an instance of ExampleClass which is a subclass of Object, which has your multiply method

Ruby method scope?

3 Answers3