• Andy Friesen (37/37) Jul 31 2004 Given:

Andy Friesen <andy ikagames.com> writes:

Given:

     import std.stdio;

     template Test(T) {
         void Test() {
             writefln("Scalar: ", typeid(T).toString());
         }
     }

     template Test(ArrayType : ArrayType[]) {
         void Test() {
             writefln("Array: ", typeid(ArrayType).toString());
         }
     }

     template Test(ValueType, KeyType : KeyType[ValueType]) {
         void Test() {
             writefln("Associative array ",
                 typeid(KeyType).toString(), " => ",
                 typeid(ValueType).toString());
         }
     }

     int main() {
         Test!(int)();
         Test!(char[])();
         Test!(int, int[int])();
         return 0;
     }

The last template instantiation in main() fails because no match was found.

Renaming ValueType to either ArrayType or T causes the compile to succeed.

Even then, though, the match only succeeds if the first argument, and 
the key *and* value types of the second, are identical.  (eg Test!(real, 
real[real]) works, but Test!(int, char[int]) does not)

Sort of related but separate issue: Changing the second instantiation to 
Test!(float[][]) causes the link to fail. (no TypeInfo for float[], I 
assume)

Also sort of related:  It is legal to write

     template Foo(T : void delegate(T)) { ... }

However, as far as I can tell, the specialization is never selected.

  -- andy