Hello,

I'm coming late to the discussion, but I believe that you can use the following idiom to achieve the same results in a different way:

class C
{
   // This is not overridable
   public final void doStuff()
   {
      doSomethingWhichNeverChanges();
      doExtraStuff();
   }

   protected void doExtraStuff()
   {
      // This one can be overridden
   }
}

Or did I miss something?

Cheers,

LMB




On Mon, Feb 24, 2014 at 5:41 AM, Steve Teale <steve.teale@britseyeview.com> wrote:
25 years ago, when I was trying to write some sort of library to go with Walter's C++ compiler, I had a wish, and it still pops into my head from time to time.

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?

Steve