What's wrong with D's templates?

[BCS]

Hello Yigal,

> On 18/12/2009 17:34, dsimcha wrote:
> 
>> I think variadics, static if and alias parameters qualify more as a
>> "better design" than fixing "minor issues".
>> 
> actually they qualify as - "even worse design". duplicating the syntax
> like that is butt ugly.
> 

I for one think that it's a better design than C++ has. (Given that 99% of 
what they do, C++ was never designed to do at all, you'd be hard pressed 
to come up with a worse design without trying to.)

If you can come up with an even better design for compile time stuff, I'd 
be interested.

>the conflation of user-code and library code.

Could you elaborate on this?

> 
>>> but even more frustrating is the fact that
>>> template compilation bugs will also happen at the client.

Jumping back a bit; which client? The one with the compiler or the end user?

If the first; removing this puts major limits on what can be done because 
you can't do anything unless you be sure it will work with the open set of 
types that could be instanceiated, including ones you don't know about yet. 
I know some system like c# requiter you to define what you will do to a type 
at the top and then enforce that. IMHO this is a non-solution. Without be 
to silly I think I could come up with a library that would requiter a solution 
to the halting problem in order to check that the template code can't generate 
and error with the given constants and that a given type fits the constraints, 
both without actuality instanceate the template for the type.

If the second; nether D nor C++ have to worry about that.

> .Net generics for example work by creating an instantiation for each
> value type (same as c++ templates) and one instantiation for all
> reference types since at the binary level all reference types are
> simply
> addresses.

I don't know how it does it but there has to be more to it in C# because 
they allow you to do thing to the objects that Object doesn't support. For 
that to happen, the objects have to be wrapped or tagged or something so 
that the generics code can make "foo.MyFunction()" work for different types. 
If I has to guess, I'd guess it's done via a vtable either as a "magic" interface 
or as a fat pointer.

Oh, and if the above is garbage because C# can't access totally independent 
methods from a generic, then right there is my next argument against generics.