From: Xavier Noria <fxn@...>
Date: 2012-08-07T23:14:01+09:00
Subject: Re: Nesting and constants

--047d7b10cdf98478b104c6ad98e8
Content-Type: text/plain; charset=UTF-8

On Tue, Aug 7, 2012 at 4:02 PM, Thomas Thomassen <lists@ruby-forum.com>wrote:

module TT_Test
>
>   module Foo
>     CHEESE = 'I am Foo!'
>     module Bar
>       def self.prod
>         puts CHEESE
>       end
>       def self.q
>       p Module.nesting
>     end
>     end # Bar
>     def self.q
>       p Module.nesting
>     end
>   end # Foo
>
>
>   module Foo::Biz
>     def self.prod
>       puts CHEESE
>     end
>     def self.q
>       p Module.nesting
>     end
>   end # Foo
>
> end # TT_Test
>
>
> TT_Test::Foo.q
> # => [TT_Test::Foo, TT_Test]
>
> TT_Test::Foo::Bar.q
> # => [TT_Test::Foo::Bar, TT_Test::Foo, TT_Test]
>
> TT_Test::Foo::Bar.q
> # => [TT_Test::Foo::Bar, TT_Test]
>
> TT_Test::Foo.constants
> # => ["Biz", "Bar", "CHEESE"]
>
> My question is: Why is the constant scope different between Bar and Biz
> - despite that they both exist under TT_Test::Foo ? I mean, if TT_Test
> got a constant named "Foo::Biz" I would have understood the constant
> lookup.
>


The module keyword pushes to the nesting the module it has opened (either
just created or reopened).

Therefore, in

    module M
      module N
        p Module.nesting # => [M::N, M]
      end
    end

because first we open M, and then in a nested call we open M::N. But on the
other hand

    module M::N
      p Module.nesting # => [M::N]
    end

opens M::N and that's it. Nesting gets just that one module object pushed.

Note that what we push are module objects, not constants:

    module M
    end

    N = M

    module N
      p Module.nesting # => [M]
    end

In the example above, N evaluates to the module object stored in the
constant M, that's the module object being reopened and therefore pushed to
the nesting.

--047d7b10cdf98478b104c6ad98e8
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

On Tue, Aug 7, 2012 at 4:02 PM, Thomas Thomassen <span dir=3D"ltr">&lt;<a h=
ref=3D"mailto:lists@ruby-forum.com" target=3D"_blank">lists@ruby-forum.com<=
/a>&gt;</span> wrote:<div><br><div class=3D"gmail_quote"><blockquote class=
=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padd=
ing-left:1ex">


module TT_Test<br>
<br>
=C2=A0 module Foo<br>
=C2=A0 =C2=A0 CHEESE =3D &#39;I am Foo!&#39;<br>
=C2=A0 =C2=A0 module Bar<br>
=C2=A0 =C2=A0 =C2=A0 def self.prod<br>
=C2=A0 =C2=A0 =C2=A0 =C2=A0 puts CHEESE<br>
=C2=A0 =C2=A0 =C2=A0 end<br>
=C2=A0 =C2=A0 =C2=A0 def self.q<br>
=C2=A0 =C2=A0 =C2=A0 p Module.nesting<br>
=C2=A0 =C2=A0 end<br>
=C2=A0 =C2=A0 end # Bar<br>
=C2=A0 =C2=A0 def self.q<br>
=C2=A0 =C2=A0 =C2=A0 p Module.nesting<br>
=C2=A0 =C2=A0 end<br>
=C2=A0 end # Foo<br>
<br>
<br>
=C2=A0 module Foo::Biz<br>
=C2=A0 =C2=A0 def self.prod<br>
=C2=A0 =C2=A0 =C2=A0 puts CHEESE<br>
=C2=A0 =C2=A0 end<br>
=C2=A0 =C2=A0 def self.q<br>
=C2=A0 =C2=A0 =C2=A0 p Module.nesting<br>
=C2=A0 =C2=A0 end<br>
=C2=A0 end # Foo<br>
<br>
end # TT_Test<br>
<br>
<br>
TT_Test::Foo.q<br>
# =3D&gt; [TT_Test::Foo, TT_Test]<br>
<br>
TT_Test::Foo::Bar.q<br>
# =3D&gt; [TT_Test::Foo::Bar, TT_Test::Foo, TT_Test]<br>
<br>
TT_Test::Foo::Bar.q<br>
# =3D&gt; [TT_Test::Foo::Bar, TT_Test]<br>
<br>
TT_Test::Foo.constants<br>
# =3D&gt; [&quot;Biz&quot;, &quot;Bar&quot;, &quot;CHEESE&quot;]<br>
<br>
My question is: Why is the constant scope different between Bar and Biz<br>
- despite that they both exist under TT_Test::Foo ? I mean, if TT_Test<br>
got a constant named &quot;Foo::Biz&quot; I would have understood the const=
ant<br>
lookup.<br></blockquote><div><br></div><div><br></div><div>The module keywo=
rd pushes to the nesting the module it has opened (either just created or r=
eopened).</div><div><br></div><div>Therefore, in</div><div><br></div><div>


=C2=A0 =C2=A0 module M</div><div>=C2=A0 =C2=A0 =C2=A0 module N</div><div>=
=C2=A0 =C2=A0 =C2=A0 =C2=A0 p Module.nesting # =3D&gt; [M::N, M]</div><div>=
=C2=A0 =C2=A0 =C2=A0 end</div><div>=C2=A0 =C2=A0 end</div><div><br></div><d=
iv>because first we open M, and then in a nested call we open M::N. But on =
the other hand</div>


<div><br></div><div>=C2=A0 =C2=A0 module M::N</div><div>=C2=A0 =C2=A0 =C2=
=A0 p Module.nesting # =3D&gt; [M::N]</div><div>=C2=A0 =C2=A0 end</div><div=
><br></div><div>opens M::N and that&#39;s it. Nesting gets just that one mo=
dule object pushed.</div><div><br>

</div><div>Note that what we push are module objects, not constants:</div><=
div><br></div><div>=C2=A0 =C2=A0 module M</div><div>=C2=A0 =C2=A0 end</div>=
<div><br></div><div>=C2=A0 =C2=A0 N =3D M</div><div><br></div><div>=C2=A0 =
=C2=A0 module N</div><div>=C2=A0 =C2=A0 =C2=A0 p Module.nesting # =3D&gt; [=
M]</div>

<div>=C2=A0 =C2=A0 end</div><div><br></div><div>In the example above, N eva=
luates to the module object stored in the constant M, that&#39;s the module=
 object being reopened and therefore pushed to the nesting.</div><div><br><=
/div>
<div>
=C2=A0=C2=A0</div>
</div></div>

--047d7b10cdf98478b104c6ad98e8--