🚀 go-pugleaf

Summary:  We need a way to specify that a virtual function's implementation
          should not be inherited.


There are currently three general ways of declaring member functions, with
three corresponding meanings.  For a class C, we can say:

    1.          void C::foo()   { ... }
    2.  virtual void C::foo()   { ... }  // yes, I know "virtual" is
    3.  virtual void C::foo() = 0;       // illegal outside the class decl...

In all three cases, foo is a concept that makes sense for all objects of
type C or any of its subclasses, but there are additional semantics, as
follows: 

    1.  foo's implementation makes sense for all objects of type C or any
        of its subclasses.  In essense, foo's implementation is an
        assertion about an *invariant* aspect of C's semantics, and
        redefinitions of foo in subclasses are suspect.

    2.  foo's implementation provides reasonable default semantics for C
        objects and specializations of C, but foo's implementation often
        needs to change as C is specialized.

    3.  it is not possible to provide default behavior for foo, but the
        concept applies to all objects of type C, and a definition for foo
        must be provided before a subclass may be instantiated.

I propose that we need a forth form, one that means:

    4.  foo identifies an attribute which MUST differentiate
        specializations of C, hence no definition of foo may be inherited.
        (This is in some sense the diametric opposite of case 1.)

As a contrivied example, consider a function we're never supposed to need,
but that is damned useful nonetheless:

    virtual const char * C::className() const { return "C"; }

Here is a member function that should *always* be redefined in subclasses.
Unfortunately, there is no way to require that it be done.

To get the semantics I propose, we need new syntax, always a bad sign.  For
pure virtual functions, a simple application of the "when in doubt, assign
a new meaning to 'const'" rule seems possible:

    virtual void C::foo() const = const 0;
                                  ^^^^^
        // foo is pure virtual in C, and once defined, it must be
        // defined in all further subclasses.  (The extra const suggests
        // "it's inherited definition is ALWAYS null.")

For non-pure (impure?) virtual functions, I'm not sure what to suggest;
the last thing we need is another keyword.

Has anybody besides me ever wanted to have a way to express a requirement
that a function MUST be redefined in subclasses?

Scott
sdm@cs.brown.edu