Idea: Class extension as an interface

[Michel Fortin]

I'd like to propose a class extension that allows overriding members. 
What I'm proposing is that:

1. you can create a class extension for a given class you want to 
extend, such an extension
   containing member function definitions which would become available 
to any user of that
   class if he has included the extension's module;
2. functions definitions in the class extension can only access the 
public-accessible members
   of the extended class, package-accessible members if they're in the 
same package, or
   private-accessible memebers if they're in the same module;
3. extensions implicitly create an interface which can be reimplemented 
in a derivative of
   the extended class if the need arise to override some of the 
extension functions.

Calling a non-final extension method would enquire the following 
process: check if the class implements the given extension interface; 
if it does: call from there; if it does not: call the base extension 
method. Making an extension method final means that the function cannot 
be reimplemented by subclasses, allowing us to bypass this process.

Here's a simple example:

~~~~~~
class A {
	string exp;
	string toExpression() { return exp; }
}

// Extension interface for A, providing functions to be used with any A 
descendent
extension Ext : A {
	string toQuotedExpression() { return quote(toExpression()); }
}

// Class B derives from A and reimplements Ext more efficiently.
class B : A, Ext {
	string quotedExp;
	override string toQuotedExpression() { return quotedExp; }
}
~~~~~~

This way, A's implemententor doesn't need to know about any extension 
interfaces applying to A, and A's subclasser can still override any 
extension he wishes, if he has access to it and it makes sense.

Perhaps such extensions could also be defined for structs, typedefs or 
primitive types. In those cases however, functions cannot be overriden.

-- 
Michel Fortin
michel.fortin at michelf.com
http://michelf.com/