On Monday, 24 February 2014 at 08:41:06 UTC, Steve Teale wrote:
What I wanted was functions that were declared in a base class
as 'cumulative', or something similar. They would have been
generally like virtual functions, except that any derived class
that wanted to do something extra - as opposed to something
different, would simply define an 'extend', and just specify
the extra code. The compiler would then automatically add a
call to the same function in whatever base class last defined
or extended the method.
extend void foo() // Declared in base class as cumulative
void foo()
{
(cast(BaseClass) this).foo(); // Compiler does this for you
// similar to changing a
light bulb ;=)
// the extra stuff
}
I think also that it might be necessary for the base class
function to return on behalf of the derived method as opposed
to to it.
Does this make any sense?
Yes. This is "inner virtual functions" as opposed to "outer
virtual functions" (C++). The successor to Simula, BETA
(http://daimi.au.dk/~beta/), has this. Simula has this in the
constructor of a class (which syntactically is the body), but
BETA has the concept everywhere:
somefunction:<(#
statements1;
inner;
statements2;
#)
When you specialize a function/class the extra stuff you add is
replacing the "inner" statement (and can provide it's own
"inner").
It provides for better encapsulation/enforcing invariants.
