convert this:

using namespace "xyz"
 class String
   def go
   end
 end
end

using namespace "xyz"
 'abc'.go
end

to this:

 class String
   def go_namespace_xyz
   end
 end
end

 'abc'.go_namespace_xyz

How? By remembering 'in namespace xyz, I have previously defined a go
method' and assuming that that's the one they really want.

The biggest questions I've had with regards to namespacing are:

* How do you define the scope? Keep in mind that Ruby scopes are only
partially determined at compile time, and constant lookups (for
example) are not resolved until runtime
* How do you know what code should see the namespacing? Should it be
all code downthread from a namespacing call, or should it be only code
local to some Ruby structure (file, module, block)

Groovy is the only language I know of that has attempted to implement
this sort of namespacing, using a "downthread" approach, and I know
it's caused them a lot of problems over time.

Another possibility that might work cross VM might be to specify known
scopes, like

all_scopes_are :scope1, :scope2, :scope3

Then in each (all) currently existing calsses, alias *all* methods to
their scope equivalents, like

String#each_line => String#each_line_scope1
String#downcase => String#downcase_scope1

Then when you run into a block like

using scope1 do
   ''.downcase
end

You translate it (pre processor?) to

''.downcase_scope1

namespace Foo
  class Bar
    def baz
    end
  end
end

Class definitions in Ruby are not really static class definitions;
they're just opening (and possibly instantiating) a Class object and
running code against it. Same goes for Modules and constants defined
anywhere; they can't be sorted out statically ahead-of-time (the best
you can do is guess based on standard patterns).

In JRuby we've had to deal with this to support compiling Ruby into
Java classes. Specifically, we have started to support translating the
"apparent" static structure of a Ruby class into the equivalent Java
class structure, without actually running the code. It's tweaky,
though, and it's easy to walk off the edge of what we can support
statically.

The namespacing stuff you're talking about would definitely be nice to
have statically supported, but statically propagating it across files
leads right back into the same problems...since Ruby files know
nothing of each other until runtime.

It's a hard problem, and part of the reason I haven't said more about
it or tried to implement more prototypes is because I haven't found a
solution that doesn't have a lot of ugly warts. I suspect Matz is in
the same boat...