Making inheritance less tedious

[Kristian Kilpi]

I think class inheritance is a bit(?) tedious sometimes (that is,  
unnecessarily tedious).
(I leave interfaces out of this discussion.) 'Problems', IMHO, with it are:

1) You cannot inherit constructors.

2) A function will hide inherited functions having the same name.

3) The syntax for calling a super function of the base class is redundant  
and (could be) tedious.

For the case 2 there is an 'alias hack' (e.g. 'alias Base.foo foo;'), but  
it's redundant and ugly.
Recently this issue was discussed in the thread 'aliasing base methods'  
started by Frank Benoit
(http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=49572),  
so I don't
talk about it here.


There should be some way to 'break' the case 1. For example, the following  
is laborious and error-prone:

   class CheckBox {
     this();
     this(string label);
     this(Icon icon, string label = null);

     void draw();
   }

   class MyCheckBox : CheckBox {
     this() {
       super();
     }
     this(string label) {
       super(label);
     }
     this(Icon icon, string label = null) {
       super(icon, label);
     }

     void draw();
   }

All I wanted was to reimplement the 'draw()' function. But I had to write  
all those redundant constructors also!
(Imagine if there were 20 or so constructors in the base class -- yes,  
it's possible in some situations.)
Surely there should be a simple solution for this?

For example, something like this:

   class MyCheckBox : CheckBox {
     inherit constructors;

     void draw();
   }

Or better yet:

   class MyCheckBox : inherit CheckBox {
     void draw();
   }


What about the case 3? Well, lets have the following member function:

   foo(int value, int x, int y, bool is_clipped, bool is_inverted, string  
label = null) {
     ...

     super.foo(value, x, y, is_clipped, is_inverted, label);
   }

It would be nice to have the following possible:

   foo(int value, int x, int y, bool is_clipped, bool is_inverted, string  
label = null) {
     ...

     superfunc(..);  //equals to 'super.foo(value, x, y, is_clipped,  
is_inverted, label);'
   }

'superfunc(..)' (or 'superfunc($)' or something) is non-redundant, easy to  
read, and
trivial to maintain (because no maintenance is needed! :) ).

You can of course define the arguments by yourself if needed:

   superfunc(value + 1, x, y, false, is_inverted);