From: Charles Oliver Nutter <charles.nutter@...>
Date: 2007-12-23T04:14:35+09:00
Subject: Re: Matz says namespaces are too hard to implement - why?

Robert Klemme wrote:
> 2007/12/22, Stefan Rusterholz <apeiros@gmx.net>:
>> But I think I begin to see a thought mistake. I guess I have
>> to think about it a bit :-/
> 
> Actually that fits well with what I was going to suggest: it seemed to
> me that you did not have yet fully made up your mind what you want.
> :-)  I doubt though that a lexical solution would be as useful as a
> call stack scoped one.

Ditto, though I'm not a fan of selector namespacing yet anyway.

> Also, Charles, maybe implementation implications for lexical scoped
> changes might be less dramatic but wouldn't they still impose a
> performance penalty at runtime?  I mean, the issue of checking would
> not change whether it's dynamically or lexically scoped.  And there
> must be a penalty because of Ruby's dynamic nature, i.e. since it's
> not compiled you cannot decide at compile time which version of a
> method needs to be invoked.  When I think about it it may even make
> implementation more difficult, because then the set of current methods
> changes even more (i.e. when you redefine a method in a namespace and
> invoke that method from another method invoked in that namespace the
> old definition would apply again; this also imposes the interesting
> question if recursion with redefined methods is still possible... :-))
>  A lot of interesting problems to solve. :-)

Yes, lexically scoped namespaces would have the same performance 
implications call-stack scoped namespaces iff they were applied 
dynamically at runtime. If they were applied statically at parse time, 
via a keyword or other syntax, the overhead of checking for a namespace 
would be limited to specific chunks of code:

(assume "namespace" is a keyword)

my_string.rb:
class StringDecorate
   def foo
     "woohoo!"
   end
end

foo.rb:
namespace String => StringDecorate {
   "".foo # => "woohoo!"
}
"".foo # => error

So the idea here is that since namespace is a keyword, at parse or 
compile time everything inside the block would be decorated with 
namespace-checking logic. And more importantly, everything outside the 
block would remain blissfully unaware of namespace checking at all.

But this is still predicated on the idea that lexically-scoped 
namespacing is actually useful.

- Charlie