Cumulative

[Ola Fosheim Grøstad" <ola.fosheim.grostad+dlang at gmail.com>]

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.