Preference of code style in module nesting

Question

I got bit by assuming that

module A
  module B
  end
end

and

module A::B
end

are alike. I was able to find a solution from this blog, this SO thread and and this SO thread.

Why and when should one prefer the compact syntax A::B over the other, given that it evidently has a drawback? I have a intuition that it could be related to performance, as looking up constants in more namespaces requires more computation. But I was not able to verify this by benchmarking normal classes.

Ir relates to readability only: 1 level of indent less. Also, there is a tiny chance to catch typos upfront. — Aleksei Matiushkin, Feb 23 '18 at 06:27
@mudasobwa - not exactly same, if you define a constant in `module A`, you won't be able to access it directly in the latter version as lookup won't find it. — Surya, Feb 23 '18 at 06:32
@Surya true that; I always forget about that glitch, since I do simply remember “constant lookup in ruby is flaky” mantra :) — Aleksei Matiushkin, Feb 23 '18 at 06:33

tukan · Accepted Answer · 2018-02-26T07:42:14.207

These two methods of writing get confused quite often.

First is to say, that to my best knowledge there is no measurable performance difference. (one constant look-up in the below written example)

The most obvious difference, probably the most known, is that your second example (module A::B) requires for the module A to exist in the time of the definition.

Otherwise than than that most people think they are interchangeable. That is not true.

Modules are simply constants in ruby and so regular constant look-up applies.

Let me show it on an example:

module A
  class Test
  end

  module B
    class Show
      p Module.nesting # =>[A::B::Show, A::B, A]

      def show_action
        Test.respond_with(%q(I'm here!))
      end
    end
  end
end

On the other hand if you call it via the A::B look what happens:

module A
  class Test
  end
end

module A::B
  class Show
    p Module.nesting # => [A::B::Show, A::B]

    def show_action
      Test.respond_with(%q(I'm here!))
    end
  end
end

The difference is that .nesting produces:

1) in the first case: [A::B::Show, A::B, A] (you are nested in module A)

2) in the second case: [A::B::Show, A::B] (here not)

score 1 · Answer 2 · answered Feb 23 '18 at 08:25

The first one has more information than the second one. Naturally, in most cases, you can assume that the second form can always be replaced by the first one, but not the other way around. In fact, you cannot use the second form unless A is defined in advance. But be careful that the return values of Module#nesting differ between the two forms as the method has lexical scope interpretation.

Preference of code style in module nesting

2 Answers2