# Module This::Encompassing::That

**URL:** <https://rubytalk.org/t/module-this-encompassing-that/4723>\
**Category:** ruby-talk\
**Created:** [14 February 2003 02:34 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723 "2003-02-14T02:34:39Z")\
**Posts on this page:** 20\
**Page:** 1

<div class="post-metadata">

**Author:** ![Bil\_Kleb2](https://avatars.discourse-cdn.com/v4/letter/b/6a8cbe/32.png) [@Bil\_Kleb2](https://rubytalk.org/u/Bil_Kleb2)\
**Post date:** [14 February 2003 02:34 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/1 "2003-02-14T02:34:39Z")

</div>

Today, I decided I was tired of

module This  
module Encompassing  
module That  
finally\_some\_really\_overly\_indented\_code  
end  
end  
end

and tried,

module This::Encompassing::That  
some\_much\_less\_indented\_code  
end

since I already do things like,

This::Encompassing::That.module\_method

but alas, it didn’t work.

Is there a reason why these two module aspects are not more aligned?  
I haven’t looked at the source, but it seems that the module parsing  
must already be in place for constructs like This::Encompassing::That,  
so what not allow it for defining modules too?

Thanks

> **···**
>
> –  
> Bil Kleb  
> NASA Langley Research Center  
> Hampton, Virginia, USA

---

<div class="post-metadata">

**Author:** ![David\_Alan\_Black1](https://avatars.discourse-cdn.com/v4/letter/d/278dde/32.png) [@David\_Alan\_Black1](https://rubytalk.org/u/David_Alan_Black1)\
**Post date:** [14 February 2003 02:38 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/2 "2003-02-14T02:38:22Z")

</div>

Hi –

> Today, I decided I was tired of
> 
> module This  
> module Encompassing  
> module That  
> finally\_some\_really\_overly\_indented\_code  
> end  
> end  
> end
> 
> and tried,
> 
> module This::Encompassing::That  
> some\_much\_less\_indented\_code  
> end
> 
> since I already do things like,
> 
> This::Encompassing::That.module\_method
> 
> but alas, it didn’t work.
> 
> Is there a reason why these two module aspects are not more aligned?  
> I haven’t looked at the source, but it seems that the module parsing  
> must already be in place for constructs like This::Encompassing::That,  
> so what not allow it for defining modules too?

It’s possibly because that notation can mean more than one thing:

module X  
module Y  
class Z

or

module X  
module Y  
Z = 100

so there’s no way to determine from the :: notation what you’re  
intending to create.

David

> **···**
>
> On Fri, 14 Feb 2003, Bil Kleb wrote:
> 
> –  
> David Alan Black  
> home: [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net)  
> work: blackdav@shu.edu  
> Web: [http://pirate.shu.edu/~blackdav](http://pirate.shu.edu/~blackdav)

---

<div class="post-metadata">

**Author:** ![Bil\_Kleb2](https://avatars.discourse-cdn.com/v4/letter/b/6a8cbe/32.png) [@Bil\_Kleb2](https://rubytalk.org/u/Bil_Kleb2)\
**Post date:** [14 February 2003 03:00 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/3 "2003-02-14T03:00:56Z")

</div>

[dblack@candle.superlink.net](mailto:dblack@candle.superlink.net) wrote:

> so there’s no way to determine from the :: notation what you’re  
> intending to create.

Excellent point.

Thanks,

> **···**
>
> –  
> Bil

---

<div class="post-metadata">

**Author:** ![Gavin\_Sinclair](https://avatars.discourse-cdn.com/v4/letter/g/db5fbb/32.png) [@Gavin\_Sinclair](https://rubytalk.org/u/Gavin_Sinclair)\
**Post date:** [15 February 2003 14:04 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/4 "2003-02-15T14:04:06Z")

</div>

However, since the idea of the “module” keyword is to introduce a new  
module or reuse an existing one, I don’t see why the OP’s idea  
couldn’t work.

module X  
module Y  
module Z  
end  
C = 100  
end  
end

module X::Y  
def foo; end  
end # could work - use existing module

module X::Y::Z  
def foo; end  
end # could work - use existing module

module X::Y::C  
def foo; end  
end # error; C is a constant

module X::Y::Z::A  
def foo; end  
end # could work - creates new module

I like the idea.

Gavin

> **···**
>
> On Friday, February 14, 2003, 2:00:56 PM, Bil wrote:
> 
> > [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net) wrote:
> > 
> > > so there’s no way to determine from the :: notation what you’re  
> > > intending to create.
> 
> > Excellent point.

---

<div class="post-metadata">

**Author:** ![ts1](https://avatars.discourse-cdn.com/v4/letter/t/a8b319/32.png) [@ts1](https://rubytalk.org/u/ts1)\
**Post date:** [15 February 2003 14:07 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/5 "2003-02-15T14:07:20Z")

</div>

> module X::Y

it's in the ToDo

&nbsp;&nbsp;&nbsp;\* class Foo::Bar\<Baz .. end, module Boo::Bar .. end  
&nbsp;&nbsp;&nbsp;\* def Foo::Bar::baz() .. end ??

Guy Decoux

---

<div class="post-metadata">

**Author:** ![Nobuyoshi\_Nakada](https://avatars.discourse-cdn.com/v4/letter/n/edb3f5/32.png) [@Nobuyoshi\_Nakada](https://rubytalk.org/u/Nobuyoshi_Nakada)\
**Post date:** [15 February 2003 14:27 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/6 "2003-02-15T14:27:51Z")

</div>

Hi,

> **···**
>
> At Sat, 15 Feb 2003 23:04:06 +0900, Gavin Sinclair wrote:
> 
> > However, since the idea of the “module” keyword is to introduce a new  
> > module or reuse an existing one, I don’t see why the OP’s idea  
> > couldn’t work.
> > 
> > module X  
> > module Y  
> > module Z  
> > end  
> > C = 100  
> > end  
> > end
> > 
> > module X::Y  
> > def foo; end  
> > end # could work - use existing module
> 
> You can use module\_eval.
> 
> X::Y.module\_eval do  
> def foo; end  
> end
> 
> –  
> Nobu Nakada

---

<div class="post-metadata">

**Author:** ![David\_Alan\_Black1](https://avatars.discourse-cdn.com/v4/letter/d/278dde/32.png) [@David\_Alan\_Black1](https://rubytalk.org/u/David_Alan_Black1)\
**Post date:** [15 February 2003 17:01 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/7 "2003-02-15T17:01:47Z")

</div>

Hi –

> > > so there’s no way to determine from the :: notation what you’re  
> > > intending to create.
> 
> > Excellent point.
> 
> However, since the idea of the “module” keyword is to introduce a new  
> module or reuse an existing one, I don’t see why the OP’s idea  
> couldn’t work.

I assumed he meant a kind of autovivification, so that the first  
line in a program could be:

module A:🅱:C

which would suffer from the ambiguity I mentioned. But if it’s  
incremental – i.e., if the above requires that A and B already exist  
and be a valid path to a new module definition (namely, C) – that  
seems OK.

David

> **···**
>
> On Sat, 15 Feb 2003, Gavin Sinclair wrote:
> 
> > On Friday, February 14, 2003, 2:00:56 PM, Bil wrote:
> > 
> > > [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net) wrote:
> 
> –  
> David Alan Black  
> home: [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net)  
> work: blackdav@shu.edu  
> Web: [http://pirate.shu.edu/~blackdav](http://pirate.shu.edu/~blackdav)

---

<div class="post-metadata">

**Author:** ![Gavin\_Sinclair](https://avatars.discourse-cdn.com/v4/letter/g/db5fbb/32.png) [@Gavin\_Sinclair](https://rubytalk.org/u/Gavin_Sinclair)\
**Post date:** [15 February 2003 23:18 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/8 "2003-02-15T23:18:06Z")

</div>

I don’t see a problem with autovivification, though. If the first  
line in a program is

module A:🅱:C

what conceptually prevents this from being equivalent to

module A  
module B  
module C

?

Naturally, if A::B is a (non-Module) constant, then an error would  
result.

Gavin

> **···**
>
> On Sunday, February 16, 2003, 4:01:47 AM, dblack wrote:
> 
> > Hi –
> 
> > On Sat, 15 Feb 2003, Gavin Sinclair wrote:
> 
> > > On Friday, February 14, 2003, 2:00:56 PM, Bil wrote:
> > > 
> > > > [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net) wrote:
> > > > 
> > > > > so there’s no way to determine from the :: notation what you’re  
> > > > > intending to create.
> > > 
> > > > Excellent point.
> > > 
> > > However, since the idea of the “module” keyword is to introduce a new  
> > > module or reuse an existing one, I don’t see why the OP’s idea  
> > > couldn’t work.
> 
> > I assumed he meant a kind of autovivification, so that the first  
> > line in a program could be:
> 
> > module A:🅱:C
> 
> > which would suffer from the ambiguity I mentioned. But if it’s  
> > incremental – i.e., if the above requires that A and B already exist  
> > and be a valid path to a new module definition (namely, C) – that  
> > seems OK.

---

<div class="post-metadata">

**Author:** ![Yukihiro\_Matsumoto2](https://avatars.discourse-cdn.com/v4/letter/y/b9e5f3/32.png) [@Yukihiro\_Matsumoto2](https://rubytalk.org/u/Yukihiro_Matsumoto2)\
**Post date:** [17 February 2003 16:13 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/9 "2003-02-17T16:13:53Z")

</div>

Hi,

> **···**
>
> In message “Re: module This::Encompassing::That” on 03/02/16, Gavin Sinclair [gsinclair@soyabean.com.au](mailto:gsinclair@soyabean.com.au) writes:
> 
> > I don’t see a problem with autovivification, though. If the first  
> > line in a program is
> > 
> > module A:🅱:C
> > 
> > what conceptually prevents this from being equivalent to
> > 
> > module A  
> > module B  
> > module C
> > 
> > ?
> > 
> > Naturally, if A::B is a (non-Module) constant, then an error would  
> > result.
> 
> What if A or B were classes?
> 
> ```
> matz.
> 
> ```

---

<div class="post-metadata">

**Author:** ![ts1](https://avatars.discourse-cdn.com/v4/letter/t/a8b319/32.png) [@ts1](https://rubytalk.org/u/ts1)\
**Post date:** [17 February 2003 16:19 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/10 "2003-02-17T16:19:40Z")

</div>

> What if A or B were classes?

I don't understand this is valid and same than `module A:🅱:C'

&nbsp;&nbsp;&nbsp;class A  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;class B  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;module C  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;end  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;end  
&nbsp;&nbsp;&nbsp;end

no ?

Guy Decoux

---

<div class="post-metadata">

**Author:** ![Gavin\_Sinclair](https://avatars.discourse-cdn.com/v4/letter/g/db5fbb/32.png) [@Gavin\_Sinclair](https://rubytalk.org/u/Gavin_Sinclair)\
**Post date:** [18 February 2003 03:43 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/11 "2003-02-18T03:43:28Z")

</div>

If it makes sense for classes, then well and good. If not, then  
error. I would avoid making it too smart (as later messages discuss),  
because then you’d be forever explaining it to everybody.

I like the idea of autovivification within certain rules.

class A  
end

module A::B  
end # error

The rule is that the Xi in  
module X1::X2::…::Xn  
must all be either:

- modules (not classes); or
- non-existent (so an empty module can be created)

Gavin

> **···**
>
> On Tuesday, February 18, 2003, 3:13:53 AM, Yukihiro wrote:
> 
> > Hi,
> 
> > In message “Re: module This::Encompassing::That” \> on 03/02/16, Gavin Sinclair [gsinclair@soyabean.com.au](mailto:gsinclair@soyabean.com.au) writes:
> 
> > > I don’t see a problem with autovivification, though. If the first  
> > > line in a program is
> > > 
> > > module A:🅱:C
> > > 
> > > what conceptually prevents this from being equivalent to
> > > 
> > > module A  
> > > module B  
> > > module C
> > > 
> > > ?
> > > 
> > > Naturally, if A::B is a (non-Module) constant, then an error would  
> > > result.
> 
> > What if A or B were classes?

---

<div class="post-metadata">

**Author:** ![Yukihiro\_Matsumoto2](https://avatars.discourse-cdn.com/v4/letter/y/b9e5f3/32.png) [@Yukihiro\_Matsumoto2](https://rubytalk.org/u/Yukihiro_Matsumoto2)\
**Post date:** [17 February 2003 16:29 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/12 "2003-02-17T16:29:57Z")

</div>

Hi,

> > What if A or B were classes?
> 
> I don’t understand this is valid and same than `module A:🅱:C’
> 
> class A  
> class B  
> module C  
> end  
> end  
> end
> 
> no ?

No. Classes and modules are not always interchangeable.

class A  
end

module A  
module B  
module C  
end  
end  
end

```
						matz.

```

> **···**
>
> In message “Re: module This::Encompassing::That” on 03/02/18, ts [decoux@moulon.inra.fr](mailto:decoux@moulon.inra.fr) writes:

---

<div class="post-metadata">

**Author:** ![David\_Alan\_Black1](https://avatars.discourse-cdn.com/v4/letter/d/278dde/32.png) [@David\_Alan\_Black1](https://rubytalk.org/u/David_Alan_Black1)\
**Post date:** [17 February 2003 16:39 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/13 "2003-02-17T16:39:32Z")

</div>

Hi –

> > What if A or B were classes?
> 
> I don’t understand this is valid and same than `module A:🅱:C’
> 
> class A  
> class B  
> module C  
> end  
> end  
> end
> 
> no ?

Yes, but the question is about autovivification – that is, if this  
were the first line in a program:

module A:🅱:C

then this:

module A  
module B  
module C

would be created automatically. My point a few messages back was that  
this is too magical, since A:🅱:C does not necessarily refer only to  
Modules.

David

> **···**
>
> On Tue, 18 Feb 2003, ts wrote:
> 
> –  
> David Alan Black  
> home: [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net)  
> work: blackdav@shu.edu  
> Web: [http://pirate.shu.edu/~blackdav](http://pirate.shu.edu/~blackdav)

---

<div class="post-metadata">

**Author:** ![David\_Alan\_Black1](https://avatars.discourse-cdn.com/v4/letter/d/278dde/32.png) [@David\_Alan\_Black1](https://rubytalk.org/u/David_Alan_Black1)\
**Post date:** [18 February 2003 13:52 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/14 "2003-02-18T13:52:44Z")

</div>

Hi –

> I like the idea of autovivification within certain rules.
> 
> class A  
> end
> 
> module A::B  
> end # error

In this case, it’s not autoviv., because A already exists, so it’s an  
explicit creation of B.

But still, why would the above be an error? Why not equivalent to:

class A  
module B  
end  
end

> The rule is that the Xi in  
> module X1::X2::…::Xn  
> must all be either:
> 
> - modules (not classes); or

Why not classes?

> - non-existent (so an empty module can be created)

But it could be an empty Class – meaning, if X2 (or whatever)  
doesn’t exist yet, there’s no reason to favor the idea that  
it’s supposed to be a Module rather than a Class. There’s just  
no way to know.

A case that’s somewhat analogous to this, but without the ambiguity,  
is:

mkdir -p a/b/c

which creates all three directories if they don’t exist. In that  
case, there’s no ambiguity; there’s nothing else they can be, because  
mkdir only does one thing in the first place. But the :: path  
notation in module A:🅱:C does not have that kind of single meaning.  
Of course, C has to be a module, and there are things that A and B  
_can’t_ be, but there’s more than one thing each of them can be.

David

> **···**
>
> On Tue, 18 Feb 2003, Gavin Sinclair wrote:
> 
> –  
> David Alan Black  
> home: [dblack@candle.superlink.net](mailto:dblack@candle.superlink.net)  
> work: blackdav@shu.edu  
> Web: [http://pirate.shu.edu/~blackdav](http://pirate.shu.edu/~blackdav)

---

<div class="post-metadata">

**Author:** ![ts1](https://avatars.discourse-cdn.com/v4/letter/t/a8b319/32.png) [@ts1](https://rubytalk.org/u/ts1)\
**Post date:** [17 February 2003 16:37 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/15 "2003-02-17T16:37:57Z")

</div>

> No. Classes and modules are not always interchangeable.

I really don't see where is the problem, sorry, with

&nbsp;&nbsp;&nbsp;module A:🅱:C

> &nbsp;&nbsp;class A  
> &nbsp;&nbsp;end

in this case this give

&nbsp;&nbsp;&nbsp;class A  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;module B  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;module C  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;end  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;end  
&nbsp;&nbsp;&nbsp;end

> &nbsp;&nbsp;module A  
> &nbsp;&nbsp;&nbsp;&nbsp;module B  
> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;module C  
> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;end  
> &nbsp;&nbsp;&nbsp;&nbsp;end  
> &nbsp;&nbsp;end

it just retrieve C

personnaly my problem is more with

&nbsp;&nbsp;class A:🅱:C \< D  
&nbsp;&nbsp;end

Guy Decoux

---

<div class="post-metadata">

**Author:** ![ts1](https://avatars.discourse-cdn.com/v4/letter/t/a8b319/32.png) [@ts1](https://rubytalk.org/u/ts1)\
**Post date:** [17 February 2003 16:46 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/16 "2003-02-17T16:46:52Z")

</div>

> would be created automatically. My point a few messages back was that  
> this is too magical, since A:🅱:C does not necessarily refer only to  
> Modules.

I'm agree with you : it's magical, but if you write `module A:🅱:C' this  
imply fatally that A and B are classes or modules.

Guy Decoux

---

<div class="post-metadata">

**Author:** ![Matt\_Armstrong](https://avatars.discourse-cdn.com/v4/letter/m/41988e/32.png) [@Matt\_Armstrong](https://rubytalk.org/u/Matt_Armstrong)\
**Post date:** [17 February 2003 17:13 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/17 "2003-02-17T17:13:43Z")

</div>

[dblack@candle.superlink.net](mailto:dblack@candle.superlink.net) writes:

> Yes, but the question is about autovivification – that is, if this  
> were the first line in a program:
> 
> module A:🅱:C
> 
> then this:
> 
> module A  
> module B  
> module C

Ruby can raise a runtime error if A and B are unknown.

Same solution can be used to “fix” autoload to allow autoloading of  
nested classes/modules.

> **···**
>
> –  
> matt

---

<div class="post-metadata">

**Author:** ![Gavin\_Sinclair](https://avatars.discourse-cdn.com/v4/letter/g/db5fbb/32.png) [@Gavin\_Sinclair](https://rubytalk.org/u/Gavin_Sinclair)\
**Post date:** [18 February 2003 23:28 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/18 "2003-02-18T23:28:13Z")

</div>

> Hi –

> > I like the idea of autovivification within certain rules.
> > 
> > class A  
> > end
> > 
> > module A::B  
> > end # error

> In this case, it’s not autoviv., because A already exists, so it’s an  
> explicit creation of B.

> But still, why would the above be an error? Why not equivalent to:

> class A  
> module B  
> end  
> end

Well, you could do that if you like.

> > The rule is that the Xi in  
> > module X1::X2::…::Xn  
> > must all be either:
> > 
> > - modules (not classes); or

> Why not classes?

I was over-zealously aiming for simplicity.

> > - non-existent (so an empty module can be created)

> But it could be an empty Class – meaning, if X2 (or whatever)  
> doesn’t exist yet, there’s no reason to favor the idea that  
> it’s supposed to be a Module rather than a Class. There’s just  
> no way to know.

The idea of the “module” keyword is to create modules 🙂

This entire proposal - autovivification or otherwise - is just syntax  
sugar. It meets a common need: to define methods within a nested  
module (that already exists) or to create a new nested module (i.e.  
only one module is vivified).

Given that, it’s probably best to drop the autovivification idea, and  
only allow that the entire path is unambiguous, save for the creation  
of a new module.

module A  
end

module A:🅱:C  
end # error

module A::B  
end

> […]

Gavin

> **···**
>
> On Wednesday, February 19, 2003, 12:52:44 AM, dblack wrote:
> 
> > On Tue, 18 Feb 2003, Gavin Sinclair wrote:

---

<div class="post-metadata">

**Author:** ![Yukihiro\_Matsumoto2](https://avatars.discourse-cdn.com/v4/letter/y/b9e5f3/32.png) [@Yukihiro\_Matsumoto2](https://rubytalk.org/u/Yukihiro_Matsumoto2)\
**Post date:** [17 February 2003 23:19 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/19 "2003-02-17T23:19:08Z")

</div>

Hi,

> > No. Classes and modules are not always interchangeable.
> 
> I really don’t see where is the problem, sorry, with
> 
> module A:🅱:C
> 
> > class A  
> > end
> 
> in this case this give
> 
> class A  
> module B  
> module C  
> end  
> end  
> end

I think too “smart” behavior delays class/module inconsistency  
detection.

> personnaly my problem is more with
> 
> class A:🅱:C \< D  
> end

Do you worry about which namespace D searched in? I guess it must be  
top level (not A nor B).

```
						matz.

```

> **···**
>
> In message “Re: module This::Encompassing::That” on 03/02/18, ts [decoux@moulon.inra.fr](mailto:decoux@moulon.inra.fr) writes:

---

<div class="post-metadata">

**Author:** ![ts1](https://avatars.discourse-cdn.com/v4/letter/t/a8b319/32.png) [@ts1](https://rubytalk.org/u/ts1)\
**Post date:** [18 February 2003 10:19 UTC](https://rubytalk.org/t/module-this-encompassing-that/4723/20 "2003-02-18T10:19:24Z")

</div>

> \> personnaly my problem is more with  
> \>  
> \> class A:🅱:C \< D  
> \> end

> Do you worry about which namespace D searched in? I guess it must be  
> top level (not A nor B).

Yes, my problem is with

&nbsp;&nbsp;&nbsp;class D  
&nbsp;&nbsp;&nbsp;end

&nbsp;&nbsp;&nbsp;module A  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;class D  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;end  
&nbsp;&nbsp;&nbsp;end

if I'm right

&nbsp;&nbsp;&nbsp;class A::B \< D  
&nbsp;&nbsp;&nbsp;end

it's not the same than

&nbsp;&nbsp;&nbsp;module A  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;class B \< D  
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;end  
&nbsp;&nbsp;&nbsp;end

Guy Decoux

[Next page](https://rubytalk.org/t/module-this-encompassing-that/4723.md?page=2)
