I’m looking on page 356 of my Programming Ruby book (the access control section), and all I see are public, protected, and private. What am I missing?

Maybe you’re just talking about open classes (or open objects). I’m no expert, but I’d guess these features can trace their lineage back much further than Ruby. Smalltalk? Some other dynamically-typed object-oriented language?

I actually had a similar idea too (I had envisioned a completely implicit this pointer), but I didn’t blog about it.

It rocks that the namespace can be “open” whereas the class is “closed”. This is one benefit of Scott Meyer’s “FooStuff” approach that I could not replicate with my enemy access qualifier.

Additionally, this would be very easy to add to the language. In my original proposal, we’d have problem with any existing source codes that already used the word “enemy”. But, since your syntax is currently illegal in C++, it should be OK to support it retroactively.

There may also be some benefits in terms of compatibility with the current rules for C++ Koenig lookup.

In short, I think it’s a great idea.

I think the language should be extended so that if you create a namespace with the same name as the class, and functions in it take an explicit “this” as a first parameter, then they can be called as members.

Por ejemplo:


class Foo
{
public:
void bar( int n ) { n_ = n; }
int bar() const { return n_; }
};

Foo foo;
foo.bar( 6 );
assert( 6 == foo.bar() );
assert( 10 == foo.baz( 4 ) );
assert( 10 == foo.bar() );


My rationale for this is that namespaces are extensible and classes are not. It’s likely that you’ll think of more functions AFTER designing the class than before, so allow convenience functions (defined in terms of public methods) to be called as though they are members.

What do you think?