root/trunk/docsrc/template.dd

Ddoc

$(SPEC_S Templates,

$(BLOCKQUOTE 
I think that I can safely say that nobody understands template mechanics. -- Richard Deyman
)

$(P Templates are D's approach to generic programming.
    Templates are defined with a $(I TemplateDeclaration):
)

$(GRAMMAR
$(GNAME TemplateDeclaration):
    $(B template) $(GLINK TemplateIdentifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt)))
        $(B {) $(GLINK2 module, DeclDefs) $(B })

$(GNAME TemplateIdentifier):
    $(I Identifier)

$(GNAME TemplateParameterList):
    $(I TemplateParameter)
$(V2          $(I TemplateParameter) ,
)   $(I TemplateParameter) , $(I TemplateParameterList)

$(GNAME TemplateParameter):
    $(GLINK TemplateTypeParameter)
    $(GLINK TemplateValueParameter)
    $(GLINK TemplateAliasParameter)
    $(GLINK TemplateTupleParameter)
$(V2          $(GLINK TemplateThisParameter))
)

$(P The body of the $(I TemplateDeclaration) must be syntactically correct
    even if never instantiated. Semantic analysis is not done until
    instantiated. A template forms its own scope, and the template
    body can contain classes, structs, types, enums, variables,
    functions, and other templates.
)
$(P
    Template parameters can be types, values, symbols, or tuples.
    Types can be any type.
    Value parameters must be of an integral type, floating point
    type, or string type and
    specializations for them must resolve to an integral constant,
    floating point constant, null, or a string literal.
    Symbols can be any non-local symbol.
    Tuples are a sequence of 0 or more types, values or symbols.
)
$(P
    Template parameter specializations
    constrain the values or types the $(I TemplateParameter) can
    accept.
)
$(P
    Template parameter defaults are the value or type to use for the
    $(I TemplateParameter) in case one is not supplied.
)

<h2>Explicit Template Instantiation</h2>

$(P
    Templates are explicitly instantiated with:
)

$(GRAMMAR
$(GNAME TemplateInstance):
    $(GLINK TemplateIdentifier) $(B !$(LPAREN)) $(GLINK TemplateArgumentList) $(B $(RPAREN))
$(V2          $(GLINK TemplateIdentifier) $(B !) $(GLINK TemplateSingleArgument))

$(GNAME TemplateArgumentList):
    $(GLINK TemplateArgument)
$(V2          $(GLINK TemplateArgument) ,
)   $(GLINK TemplateArgument) , $(I TemplateArgumentList)

$(GNAME TemplateArgument):
    $(GLINK2 declaration, Type)
    $(ASSIGNEXPRESSION)
    $(I Symbol)

$(GNAME Symbol):
    $(I SymbolTail)
    $(B .) $(I SymbolTail)

$(GNAME SymbolTail):
    $(I Identifier)
    $(I Identifier) $(B .) $(I SymbolTail)
    $(GLINK TemplateInstance)
    $(GLINK TemplateInstance) $(B .) $(I SymbolTail)

$(V2
$(GNAME TemplateSingleArgument):
    $(I Identifier)
    $(GLINK2 declaration, BasicTypeX)
    $(GLINK2 lex, CharacterLiteral)
    $(GLINK2 lex, StringLiteral)
    $(GLINK2 lex, IntegerLiteral)
    $(GLINK2 lex, FloatLiteral)
    $(B true)
    $(B false)
    $(B null)
    $(B __FILE__)
    $(B __LINE__)
)
)

$(P
    Once instantiated, the declarations inside the template, called
    the template members, are in the scope
    of the $(I TemplateInstance):
)

------
template TFoo(T) { alias T* t; }
...
TFoo!(int).t x; // declare x to be of type int*
------

$(V2
    $(P If the $(GLINK TemplateArgument) is one token long, the parentheses can be omitted:
    )
---
TFoo!int.t x;   // same as TFoo!(int).t x;
---
)

$(P
    A template instantiation can be aliased:
)

------
template TFoo(T) { alias T* t; }
alias TFoo!(int) abc;
abc.t x;    // declare x to be of type int*
------

$(P
    Multiple instantiations of a $(I TemplateDeclaration) with the same
    $(I TemplateArgumentList), before implicit conversions,
    all will refer to the same instantiation.
    For example:
)

------
template TFoo(T) { T f; }
alias TFoo!(int) a;
alias TFoo!(int) b;
...
a.f = 3;
assert(b.f == 3);   // a and b refer to the same instance of TFoo
------

$(P
    This is true even if the $(I TemplateInstance)s are done in
    different modules.
)

$(P
    Even if template arguments are implicitly converted to the same
    template parameter type, they still refer to different instances:
)

-----
struct TFoo(int x) { }
static assert(is(TFoo!(3) == TFoo!(2 + 1)));   // 3 and 2+1 are both 3 of type int
static assert(!is(TFoo!(3) == TFoo!(3u)));     // 3u and 3 are different types
-----
$(P
    If multiple templates with the same $(I TemplateIdentifier) are
    declared, they are distinct if they have a different number of
    arguments or are differently specialized.
)
$(P
    For example, a simple generic copy template would be:
)

------
template TCopy(T)
{
    void copy(out T to, T from)
    {
    to = from;
    }
}
------

$(P
    To use the template, it must first be instantiated with a specific
    type:
)

------
int i;
TCopy!(int).copy(i, 3);
------

<h2>Instantiation Scope</h2>

$(P
    $(I TemplateInstantance)s are always performed in the scope of where
    the $(I TemplateDeclaration) is declared, with the addition of the
    template parameters being declared as aliases for their deduced types.
)
$(P
    For example:
)

$(BR)$(BR)
$(U module a)
------
template TFoo(T) { void bar() { func(); } }
------

$(U module b)
------
import a;

void func() { }
alias TFoo!(int) f; // error: func not defined in module a
------

$(P
    and:
)

$(BR)$(BR)
$(U module a)
------
template TFoo(T) { void bar() { func(1); } }
void func(double d) { }
------

$(U module b)
------
import a;

void func(int i) { }
alias TFoo!(int) f;
...
f.bar();    // will call a.func(double)
------

$(P
    $(I TemplateParameter) specializations and default
    values are evaluated in the scope of the $(I TemplateDeclaration).
)

<h2>Argument Deduction</h2>

    $(P The types of template parameters are deduced for a particular
    template instantiation by comparing the template argument with
    the corresponding template parameter.
    )

    $(P For each template parameter, the following rules are applied in
    order until a type is deduced for each parameter:
    )

    $(OL 
    $(LI If there is no type specialization for the parameter,
    the type of the parameter is set to the template argument.)

    $(LI If the type specialization is dependent on a type parameter,
    the type of that parameter is set to be the corresponding part
    of the type argument.)

    $(LI If after all the type arguments are examined there are any
    type parameters left with no type assigned, they are assigned
    types corresponding to the template argument in the same position
    in the $(I TemplateArgumentList).)

    $(LI If applying the above rules does not result in exactly one
    type for each template parameter, then it is an error.)
    )

    $(P For example:)

------
template TFoo(T) { }
alias TFoo!(int) Foo1;      // (1) T is deduced to be int
alias TFoo!(char*) Foo2;    // (1) T is deduced to be char*

template TBar(T : T*) { }
alias TBar!(char*) Foo3;    // (2) T is deduced to be char

template TAbc(D, U : D[]) { }
alias TAbc!(int, int[]) Bar1;   // (2) D is deduced to be int, U is int[]
alias TAbc!(char, int[]) Bar2;  // (4) error, D is both char and int

template TDef(D : E*, E) { }
alias TDef!(int*, int) Bar3;    // (1) E is int
                // (3) D is int*
------

    $(P Deduction from a specialization can provide values
    for more than one parameter:
    )

---
template Foo(T: T[U], U)
{
    ...
}

Foo!(int[long])  // instantiates Foo with T set to int, U set to long
---

    $(P When considering matches, a class is
    considered to be a match for any super classes or interfaces:
    )

------
class A { }
class B : A { }

template TFoo(T : A) { }
alias TFoo!(B) Foo4;        // (3) T is B

template TBar(T : U*, U : A) { }
alias TBar!(B*, B) Foo5;    // (2) T is B*
                // (3) U is B
------

<h2>Template Type Parameters</h2>

$(GRAMMAR
$(GNAME TemplateTypeParameter):
    $(I Identifier)
    $(I Identifier) $(I TemplateTypeParameterSpecialization)
    $(I Identifier) $(I TemplateTypeParameterDefault)
    $(I Identifier) $(I TemplateTypeParameterSpecialization) $(I TemplateTypeParameterDefault)

$(GNAME TemplateTypeParameterSpecialization):
     $(B :) $(GLINK2 declaration, Type)

$(GNAME TemplateTypeParameterDefault):
     $(B =) $(GLINK2 declaration, Type)
)

<h3>Specialization</h3>

    $(P Templates may be specialized for particular types of arguments
    by following the template parameter identifier with a : and the
    specialized type.
    For example:
    )

------
template TFoo(T)        { ... } // #1
template TFoo(T : T[])  { ... } // #2
template TFoo(T : char) { ... } // #3
template TFoo(T,U,V)    { ... } // #4

alias TFoo!(int) foo1;         // instantiates #1
alias TFoo!(double[]) foo2;    // instantiates #2 with T being double
alias TFoo!(char) foo3;        // instantiates #3
alias TFoo!(char, int) fooe;   // error, number of arguments mismatch
alias TFoo!(char, int, int) foo4; // instantiates #4
------

    $(P The template picked to instantiate is the one that is most specialized
    that fits the types of the $(I TemplateArgumentList).
    Determine which is more specialized is done the same way as the
    C++ partial ordering rules.
    If the result is ambiguous, it is an error.
    )


$(V2
<h2>Template This Parameters</h2>

$(GRAMMAR
$(GNAME TemplateThisParameter):
    $(B this) $(I TemplateTypeParameter)
)

    $(P $(I TemplateThisParameter)s are used in member function templates
    to pick up the type of the $(I this) reference.
    )
---
import std.stdio;

struct S
{
    const void foo(this T)(int i)
    {
    writeln(typeid(T));
    }
}

void main()
{
    const(S) s;
    (&s).foo(1);
    S s2;
    s2.foo(2);
    immutable(S) s3;
    s3.foo(3);
}
---
    $(P Prints:)

$(CONSOLE
const(S)
S
immutable(S)
)
)

<h2>Template Value Parameters</h2>

$(GRAMMAR
$(GNAME TemplateValueParameter):
    $(GLINK2 declaration, BasicType) $(GLINK2 declaration, Declarator)
    $(GLINK2 declaration, BasicType) $(GLINK2 declaration, Declarator) $(I TemplateValueParameterSpecialization)
    $(GLINK2 declaration, BasicType) $(GLINK2 declaration, Declarator) $(I TemplateValueParameterDefault)
    $(GLINK2 declaration, BasicType) $(GLINK2 declaration, Declarator) $(I TemplateValueParameterSpecialization) $(I TemplateValueParameterDefault)

$(GNAME TemplateValueParameterSpecialization):
    $(B :) $(LINK2 expression.html#ConditionalExpression, $(I ConditionalExpression))

$(GNAME TemplateValueParameterDefault):
$(V2      $(B = __FILE__)
    $(B = __LINE__))
    $(B =) $(ASSIGNEXPRESSION)
)

$(V2
    $(P The $(CODE __FILE__) and $(CODE __LINE__) expand to the source
    file name and line number at the point of instantiation.)
)

    $(P Template value parameter types can be any type which can
    be statically initialized at compile time, and the value argument
    can be any expression which can be evaluated at compile time.
    This includes integers, floating point types, and strings.
    )

-----
template foo(string s)
{
    string bar() { return s ~ " betty"; }
}

void main()
{
    writefln("%s", foo!("hello").bar()); // prints: hello betty
}
-----

    $(P This example of template foo has a value parameter that
    is specialized for 10:
    )

------
template foo(U : int, int T : 10)
{
    U x = T;
}

void main()
{
    assert(foo!(int, 10).x == 10);
}
------


<h2>$(LNAME2 aliasparameters, Template Alias Parameters)</h2>

$(GRAMMAR
$(GNAME TemplateAliasParameter):
    $(B alias) $(I Identifier) $(I TemplateAliasParameterSpecialization)$(OPT) $(I TemplateAliasParameterDefault)$(OPT)
    $(B alias) $(GLINK2 declaration, BasicType) $(GLINK2 declaration, Declarator) $(I TemplateAliasParameterSpecialization)$(OPT) $(I TemplateAliasParameterDefault)$(OPT)

$(GNAME TemplateAliasParameterSpecialization):
     $(B :) $(GLINK2 declaration, Type)
     $(B :) $(GLINK2 expression, ConditionalExpression)

$(GNAME TemplateAliasParameterDefault):
     $(B =) $(GLINK2 declaration, Type)
     $(B =) $(GLINK2 expression, ConditionalExpression)
)

    $(P Alias parameters enable templates to be parameterized with
    any type of D symbol, including global names, local names, typedef
    names, module names, template names, and template instance names.
    $(V2 Literals can also be used as arguments to alias parameters.)
    )

    $(UL 
    $(LI Global names

------
int x;

template Foo(alias X)
{
    static int* p = &X;
}

void test()
{
    alias Foo!(x) bar;
    *bar.p = 3;     // set x to 3
    static int y;
    alias Foo!(y) abc;
    *abc.p = 3;     // set y to 3
}
------
    )

    $(LI Type names

------
class Foo
{
    static int p;
}

template Bar(alias T)
{
    alias T.p q;
}

void test()
{
    alias Bar!(Foo) bar;
    bar.q = 3;  // sets Foo.p to 3
}
------
    )

    $(LI Module names

------
import std.string;

template Foo(alias X)
{
    alias X.toString y;
}

void test()
{
    alias Foo!(std.string) bar;
    bar.y(3);   // calls std.string.toString(3)
}
------
    )

    $(LI Template names

------
int x;

template Foo(alias X)
{
    static int* p = &X;
}

template Bar(alias T)
{
    alias T!(x) abc;
}

void test()
{
    alias Bar!(Foo) bar;
    *bar.abc.p = 3; // sets x to 3
}
------
    )

    $(LI Template alias names

------
int x;

template Foo(alias X)
{
    static int* p = &X;
}

template Bar(alias T)
{
    alias T.p q;
}

void test()
{
    alias Foo!(x) foo;
    alias Bar!(foo) bar;
    *bar.q = 3;     // sets x to 3
}
------
    )

    $(V2 $(LI Literals
------

template Foo(alias X, alias Y)
{
    static int i = X;
    static string s = Y;
}

void test()
{
    alias Foo!(3, "bar") foo;
    writeln(foo.i, foo.s);  // prints 3bar
}
------
    ))
    )

<h2>$(LNAME2 variadic-templates, Template Tuple Parameters)</h2>

$(GRAMMAR
$(GNAME TemplateTupleParameter):
    $(I Identifier) $(B ...)
)

    $(P If the last template parameter in the $(I TemplateParameterList)
    is declared as a $(I TemplateTupleParameter),
    it is a match with any trailing template arguments.
    The sequence of arguments form a $(I Tuple).
    A $(I Tuple) is not a type, an expression, or a symbol.
    It is a sequence of any mix of types, expressions or symbols.
    )

    $(P A $(I Tuple) whose elements consist entirely of types is
    called a $(I TypeTuple).
    A $(I Tuple) whose elements consist entirely of expressions is
    called an $(I ExpressionTuple).
    )

    $(P A $(I Tuple) can be used as an argument list to instantiate
    another template, or as the list of parameters for a function.
    )

---
template Print(A ...)
{
    void print()
    {
    writefln("args are ", A);
    }
}

template Write(A ...)
{
    void write(A a) // A is a $(I TypeTuple)
            // a is an $(I ExpressionTuple)
    {
    writefln("args are ", a);
    }
}

void main()
{
    Print!(1,'a',6.8).print();            // prints: args are 1a6.8
    Write!(int, char, double).write(1, 'a', 6.8); // prints: args are 1a6.8
}
---

    $(P Template tuples can be deduced from the types of
    the trailing parameters
    of an implicitly instantiated function template:)

---
template Foo(T, R...)
{
    void Foo(T t, R r)
    {
    writefln(t);
    static if (r.length)    // if more arguments
        Foo(r);     // do the rest of the arguments
    }
}

void main()
{
    Foo(1, 'a', 6.8);
}
---
    $(P prints:)

$(CONSOLE
1
a
6.8
)
    $(P The tuple can also be deduced from the type of a delegate
    or function parameter list passed as a function argument:)

----
import std.stdio;

/* R is return type
 * A is first argument type
 * U is $(I TypeTuple) of rest of argument types
 */
R delegate(U) Curry(R, A, U...)(R delegate(A, U) dg, A arg)
{
    struct Foo
    {
    typeof(dg) dg_m;
    typeof(arg) arg_m;

    R bar(U u)
    {
        return dg_m(arg_m, u);
    }
    }

    Foo* f = new Foo;
    f.dg_m = dg;
    f.arg_m = arg;
    return &f.bar;
}

void main()
{
    int plus(int x, int y, int z)
    {
    return x + y + z;
    }

    auto plus_two = Curry(&plus, 2);
    writefln("%d", plus_two(6, 8)); // prints 16
}
----

    $(P The number of elements in a $(I Tuple) can be retrieved with
    the $(B .length) property. The $(I n)th element can be retrieved
    by indexing the $(I Tuple) with [$(I n)],
    and sub tuples can be created
    with the slicing syntax.
    )

    $(P $(I Tuple)s are static compile time entities, there is no way
    to dynamically change, add, or remove elements.)

    $(P If both a template with a tuple parameter and a template
    without a tuple parameter exactly match a template instantiation,
    the template without a $(I TemplateTupleParameter) is selected.)

<h2>Template Parameter Default Values</h2>

    $(P Trailing template parameters can be given default values:
    )

------
template Foo(T, U = int) { ... }
Foo!(uint,long); // instantiate Foo with T as uint, and U as long
Foo!(uint);  // instantiate Foo with T as uint, and U as int

template Foo(T, U = T*) { ... }
Foo!(uint);  // instantiate Foo with T as uint, and U as uint*
------

<h2>Implicit Template Properties</h2>

    $(P If a template has exactly one member in it, and the name of that
    member is the same as the template name, that member is assumed
    to be referred to in a template instantiation:
    )

------
template $(B Foo)(T)
{
    T $(B Foo); // declare variable Foo of type T
}

void test()
{
    $(B Foo)!(int) = 6; // instead of Foo!(int).Foo
}
------

<h2>Template Constructors</h2>

$(GRAMMAR
$(GNAME TemplatedConstructor):
    $(B this) $(B $(LPAREN)) $(GLINK2 template, TemplateParameterList) $(B $(RPAREN)) $(GLINK2 declaration, Parameters) $(GLINK Constraint)$(OPT) $(GLINK2 function, FunctionBody)
)

    $(P Templates can be used to form constructors for classes$(V2   and structs).
    )

<h2>Class Templates</h2>

$(GRAMMAR
$(GNAME ClassTemplateDeclaration):
    $(B class) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(GLINK Constraint)$(OPT) $(GLINK2 class, BaseClassList) $(GLINK2 class, ClassBody)
)

    $(P If a template declares exactly one member, and that member is a class
    with the same name as the template:
    )

------
template $(B Bar)(T)
{
    class $(B Bar)
    {
    T member;
    }
}
------

    $(P then the semantic equivalent, called a $(I ClassTemplateDeclaration)
    can be written as:
    )

------
class $(B Bar)(T)
{
    T member;
}
------

<h2>Struct, Union, and Interface Templates</h2>

$(GRAMMAR
$(GNAME StructTemplateDeclaration):
    $(B struct) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt))) $(LINK2 struct.html#StructBody, $(I StructBody))

$(GNAME UnionTemplateDeclaration):
    $(B union) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt))) $(LINK2 struct.html#StructBody, $(I StructBody))

$(GNAME InterfaceTemplateDeclaration):
    $(B interface) $(I Identifier) $(B $(LPAREN)) $(GLINK TemplateParameterList) $(B $(RPAREN)) $(V2 $(GLINK Constraint)$(SUB $(I opt))) $(LINK2 interface.html#BaseInterfaceList, $(I BaseInterfaceList)) $(LINK2 interface.html#InterfaceBody, $(I InterfaceBody))
)

    $(P Analogously to class templates, struct, union and interfaces
    can be transformed into templates by supplying a template parameter list.
    )

<h2>$(LNAME2 function-templates, Function Templates)</h2>

    $(P If a template declares exactly one member, and that member is a function
    with the same name as the template, it is a function template declaration.
    Alternatively, a function template declaration is a function declaration
    with a $(GLINK TemplateParameterList) immediately preceding the
    $(LINK2 declaration.html#Parameters, $(I Parameters)).
    )

    $(P A function template to compute the square of type $(I T) is:
    )
------
T $(B Square)(T)(T t)
{
    return t * t;
}
------

    $(P Function templates can be explicitly instantiated with a
    !($(I TemplateArgumentList)):
    )

----
writefln("The square of %s is %s", 3, Square!(int)(3));
----

    $(P or implicitly, where the $(I TemplateArgumentList) is deduced
    from the types of the function arguments:
    )

----
writefln("The square of %s is %s", 3, Square(3));  // T is deduced to be int
----

    $(P If there are fewer arguments supplied in the $(I TemplateArgumentList)
    than parameters in the $(I TemplateParameterList), the arguments fulfill
    parameters from left to right, and the rest of the parameters are then deduced
    from the function arguments.
    )

    $(P Function template type parameters that are to be implicitly
    deduced may not have specializations:
    )

------
void $(B Foo)(T : T*)(T t) { ... }

int x,y;
Foo!(int*)(x);   // ok, T is not deduced from function argument
Foo(&y);         // error, T has specialization
------

    $(P Template arguments not implicitly deduced can have default values:
    )

------
void $(B Foo)(T, U=T*)(T t) { U p; ... }

int x;
Foo(&x);    // T is int, U is int*
------

$(V2    $(P Function templates can have their return types deduced based
    on the first
    $(LINK2 statement.html#ReturnStatement, $(I ReturnStatement))
    in the function:
    )

---
auto $(B Square)(T)(T t)
{
    return t * t;
}
---
    $(P If there is more than one return statement, then the
    types of the return statement expressions must match.
    If there are no return statements, then the return type of the
    function template is $(CODE void).
    )
)

<h3>$(LNAME2 auto-ref-parameters, Function Templates with Auto Ref Parameters)</h3>

    $(P An auto ref function template parameter becomes a ref parameter
    if its corresponding argument is an lvalue, otherwise it becomes
    a value parameter:
    )

---
int foo(T...)(auto ref T x)
{   int result;

    foreach (i, v; x)
    {
    if (v == 10)
        assert(__traits(isRef, x[i]));
    else
        assert(!__traits(isRef, x[i]));
    result += v;
    }
    return result;
}

void main()
{   int y = 10;
    int r;
    r = foo(8);         // returns 8
    r = foo(y);         // returns 10
    r = foo(3, 4, y);   // returns 17
    r = foo(4, 5, y);   // returns 19
    r = foo(y, 6, y);   // returns 26
}
---

    $(P Auto ref parameters can be combined with auto ref return
    attributes:
    )

---
auto ref min(T, U)(auto ref T lhs, auto ref U rhs)
{
    return lhs > rhs ? rhs : lhs;
}

void main()
{   int x = 7, y = 8;
    int i;

    i = min(4, 3);     // returns 3
    i = min(x, y);     // returns 7
    min(x, y) = 10;    // sets x to 10
    static assert(!__traits(compiles, min(3, y) = 10));
    static assert(!__traits(compiles, min(y, 3) = 10));
}
---

<h2>Recursive Templates</h2>

    $(P Template features can be combined to produce some interesting
    effects, such as compile time evaluation of non-trivial functions.
    For example, a factorial template can be written:
    )

------
template factorial(int n : 1)
{
    enum { factorial = 1 }
}

template factorial(int n)
{
    enum { factorial = n* factorial!(n-1) }
}

void test()
{
    writefln("%s", factorial!(4));  // prints 24
}
------

$(V2
<h2>Template Constraints</h2>

---
$(GNAME Constraint):
    $(B if) $(B $(LPAREN)) $(I ConstraintExpression) $(B $(RPAREN))

$(I ConstraintExpression):
    $(I $(GLINK2 expression, Expression))
---

    $(P $(I Constraint)s are used to impose additional constraints
    on matching arguments to a template beyond what is possible
    in the $(GLINK TemplateParameterList).
    The $(I ConstraintExpression) is computed at compile time
    and returns a result that is converted to a boolean value.
    If that value is true, then the template is matched,
    otherwise the template is not matched.
    )

    $(P For example, the following function template only
    matches with odd values of $(CODE N):
    )

---
void foo(int N)()
    if (N & 1)
{
    ...
}
...
foo!(3)();  // ok, matches
foo!(4)();  // error, no match
---
)

<h2>Limitations</h2>

    $(P Templates cannot be used to add non-static members or
    virtual functions to classes.
    For example:
    )

------
class Foo
{
    template TBar(T)
    {
    T xx;           // becomes a static member of Foo
    int func(T) { ... } // non-virtual

    static T yy;                // Ok
    static int func(T t, int y) { ... }     // Ok
    }
}
------

    $(P Templates cannot be declared inside functions.
    )

    $(P Templates cannot add functions to interfaces:)
---
interface TestInterface { void tpl(T)(); }   // error
---
)

Macros:
    TITLE=Templates
    WIKI=Template
    GLINK=$(LINK2 #$0, $(I $0))
    GNAME=<a name=$0>$(I $0)</a>
    DOLLAR=$
    FOO=