A template is a parameterized namespace. That is, it is a namespace (a name
through which other objects can be accessed) that may be passed parameters that
can modify the nature of the stuff inside.
If a template is a compile-time function, then the equivalent of a function
call - the association of a template description with
specific arguments - is called a template instantiation.
Templates have the following properties:
* they're unique; that is, a member of a template instantiation always refers
the same as a member of the same instantiation in a different module
* they're compiletime; that is, it is impossible to instantiate a template
while the program runs.
* In D, if a template contains only one member, and its name is the same as the
template, then the member is assumed to *be* the template instantiation.
That's all!
In D, void foo(T)(T t) { } is just short for template foo(T) { void foo(T t) {
} }.
So foo!(int) == "member foo of instantiation of template foo with parameter T =
int".
There's a shortcut for this, called IFTI, "implicit function template
instantiation". If you have a function template - that is,
a template containing only one function with the same name as the template -
then calling the template as if it was a function will
simply instantiate it with the type of the arguments.
Example:
template bar(T...){ void bar(T t) { writefln(t); } }
bar(2, 3, 4); // is equivalent to
bar!(int, int, int)(2, 3, 4); // is equivalent to
bar!(int, int, int).bar(2, 3, 4);
