Templates everywhere

[Max Samukha]

On 15.03.2010 3:42, Walter Bright wrote:
> Bane wrote:
>>> ======= C++ =========
>>> template<class T> class Foo
>>> {
>>> T member;
>>> };
>>> ======= D ===========
>>> class Foo(T)
>>> {
>>> T member;
>>> }
>>> =====================
>>>
>>> Yes, it looks like a trivial change, and perhaps it is. But it makes
>>> a world of difference, because it now looks like something I do get -
>>> a parameter list to something.
>>
>> Fucking beautiful. I finally get it.
>
>
> Ya know what's funny? I had to go and double check that the C++ syntax
> above was correct. Didn't have to do that for D.

Though I love D's templates:

1. People tend to throw them in where a runtime solution would suffice. 
One example is an overload of 'clear' in the D runtime:

void clear(T)(T obj) if (is(T == class))
{
     auto defaultCtor =
         cast(void function(Object)) obj.classinfo.defaultConstructor;
     version(none) // enforce isn't available in druntime
         _enforce(defaultCtor || (obj.classinfo.flags & 8) == 0);
     immutable size = obj.classinfo.init.length;
     static if (is(typeof(obj.__dtor())))
     {
         obj.__dtor();
     }
     auto buf = (cast(void*) obj)[0 .. size];
     buf[] = obj.classinfo.init;
     if (defaultCtor)
         defaultCtor(obj);
}

Since the function uses runtime information (except for the destructor), 
it is absolutely unnecessary to instantiate the template for each 
concrete class type. A more severe problem with the code above, 
unrelated to templates, is that base class destructors are not called.

Here is a non-template implementation that should fix the problems (it 
is a template but only formally):

void clear(Dummy = void)(Object obj)
{
     auto ci = obj.classinfo;
     auto defaultCtor =
         cast(void function(Object)) ci.defaultConstructor;
     version(none) // enforce isn't available in druntime
         _enforce(defaultCtor || (ci.flags & 8) == 0);
     immutable size = ci.init.length;

     auto ci2 = ci;
     do
     {
         auto dtor = cast(void function(Object))ci2.destructor;;
         if (dtor)
             dtor(obj);
         ci2 = ci2.base;
     } while (ci2)

     auto buf = (cast(void*) obj)[0 .. size];
     buf[] = ci.init;
     if (defaultCtor)
         defaultCtor(obj);
}

BTW, I do think that base class destructor calls not compiled directly 
into derived class destructors is a mistake.

2. Templates impose functional style on programmers (see Bartosz's rant 
at 
http://bartoszmilewski.wordpress.com/2009/10/21/what-does-haskell-have-to-do-with-c/).