From: Robert Klemme <shortcutter@...>
Date: 2007-12-23T08:40:00+09:00
Subject: Re: Matz says namespaces are too hard to implement - why?

On 22.12.2007 20:14, Charles Oliver Nutter wrote:
> 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:

Yeah, you're right.  I looked more to the receiving side but did not 
think about the call location.

> (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.

Yeah, and then there is still the question what happens to recursion? 
Since the checks are lexically, you could override a recursive method 
with another one and the second invocation ends up calling the old 
version.  Spooky although I guess you could do some cute tricks with 
this. :-)

Kind regards

	robert