AutoImplement: Shouldn't it be a mixin template?

  The AutoImplement functionality in std.typecons is currently a class.
This severely and unnecessarily limits its usefulness in the following
cases:

1.  You want to implement more than one interface automagically.

2.  You want to implement stuff automatically, but also add more to the class.  For example, maybe you want to add some members to the abstract base class before auto implementing, and maybe override some of the auto implemented functionality.  Of course you could define 3 levels of inheritance (the abstract class with all the extra members, the auto implemented stuff, and the class with stuff overridden) but this is horribly verbose.

3.  You want to evaluate the automatically implemented functionality in some scope other than std.typecons, so you can import stuff.

Shouldn't we just make AutoImplement a mixin template instead?  This can be done trivially by mixing the string mixin currently used to implement it into a mixin template's scope.  It seems like it would solve all the relevant problems.  Then we could do stuff like:

interface Interface1 {
     void fun();
     void gun();
}

interface Interface2 {
     void hun();
}

class Class : Interface1, Interface2 {
     mixin AutoImplement!(Interface1, generateEmptyFunction,
isAbstractFunction);
     mixin AutoImplement!(Interface2, generateEmptyFunction,
isAbstractFunction);

     // Override the automatic implementation of fun() taking advantage of
     // template mixin name lookup rules.
    override void fun() {
        writeln("Overridden.");
     }
}

The killer use case for this would be automatic forwarding for the decorator pattern.  You could just mix in an AutoImplement that forwards all of your decorator interface functions to the encapsulated object, and then override whichever ones you need to.

Forums