root/trunk/docsrc/concepts.dd

Ddoc

$(D_S Template Constraints,

    $(P Templates are normally overloaded and matched based on the
    template arguments being matched to the template parameters.
    The template parameters can specify specializations, so that
    the template argument must match particular type patterns.
    Similarly, template value arguments can be constrained to
    match particular types.)

    $(P But this has its limitations. Many times there are
    arbitrarily more
    complex criteria for what should be accepted by the template.
    This can be used to:
    )

    $(UL
    $(LI more finely discriminate about which
     template gets instantiated for given arguments)
    $(LI provides better self-documentation about what
     characteristics template parameters must have)
    $(LI can provide better diagnostics when arguments don't match,
     rather than an obscure error message based on the irrelevant
     (to the user) internal details of the template implementation)
    )

    $(P Constraints address this by simply providing an
    expression that must evaluate at compile time to true
    after the arguments are matched to the parameters.
    If it is true, then that template is a valid match for
    the arguments, if not, then it is not and is passed over
    during overload matching.)

    $(P The constraint expression follows the template declaration
    and the $(CODE if) keyword:)

---
template Foo(int N)
        if (N & 1)
{
    ...
}
---

    $(P which constrains the template $(CODE Foo) to match only if its
    argument
    is an odd integer. Arbitrarily complex criteria can be used, as
    long as it can be computed at compile time. For example, here's
    a template that only accepts prime numbers:
    )

---
bool isprime(int n)
{
    if (n < 1 || (n & 1) == 0)
    return false;
    if (n > 3)
    {
    for (auto i = 3; i * i < n; i += 2)
    {
        if ((n % i) == 0)
        return false;
    }
    }
    return true;
}

template Foo(int N)
    if (isprime(N))
{
    ...
}

Foo!(5)    // ok, 5 is prime
Foo!(6)    // no match for Foo
---

    $(P Type constraints can be complex, too. For example, a template
    Bar that will accept any floating point type using the traditional
    type specializations:
    )
---
template Bar(T:float)
{
   ...
}
template Bar(T:double)
{
   ...
}
template Bar(T:real)
{
   ...
}
---
    $(P and the template implementation body must be duplicated
    three times. But with constraints, this can be specified
    with one template:
    )
---
template Bar(T)
    if (is(T == float) || is(T == double) || is(T == real))
{
   ...
}
---
    $(P This can be simplified by using the $(CODE isFloatingPoint)
    template in library module $(CODE std.traits):
    )
---
import std.traits;
template Bar(T)
    if (isFloatingPoint!(T))
{
   ...
}
---

    $(P Characteristics of types can be tested, such as if
    a type can be added:
    )

---
// Returns true if instances of type T can be added
template isAddable(T)
{   // Works by attempting to add two instances of type T
    const isAddable = __traits(compiles, (T t) { return t + t; });
}

int Foo(T)(T t)
    if (isAddable!(T))
{
    return 3;
}

struct S
{
    void opAdd(S s) { }   // an addable struct type
}

void main()
{
    Foo(4);   // succeeds
    S s;
    Foo(s);   // succeeds
    Foo("a"); // fails to match
}
---

    $(P Since any expression that can be computed at compile time
    is allowed as a constraint, constraints can be composed:
    )

---
int Foo(T)(T t)
    if (isAddable!(T) && isMultipliable!(T))
{
    return 3;
}
---

    $(P A more complex constraint can specify a list of operations
    that must be doable with the type, such as $(CODE isStack) which
    specifies the constraints that a stack type must have:)

----
template isStack(T)
{
    const isStack =
        __traits(compiles,
          (T t)
          {   T.value_type v = top(t);
              push(t, v);
              pop(t);
              if (empty(t)) { }
          });
}

template Foo(T)
    if (isStack!(T))
{
    ...
}
----

    $(P and constraints can deal with multiple parameters:)

---
template Foo(T, int N)
    if (isAddable!(T) && isprime(N))
{
    ...
}
---

<h2>Overloading based on Constraints</h2>

    $(P Given a list of overloaded templates with the same name,
    constraints act as a yes/no filter to determine the list
    of candidates for a match.
    Overloading based on constraints can thus be achieved by
    setting up constraint expressions that are mutually exclusive.
    For example, overloading template $(CODE Foo) so that one
    takes odd integers and the other even:
    )
---
template Foo(int N) if (N & 1)    { ... } // A
template Foo(int N) if (!(N & 1)) { ... } // B
...
Foo!(3)    // instantiates A
Foo!(64)   // instantiates B
---

    $(P Constraints are not involved with determining which
    template is more specialized than another.
    )

---
void foo(T, int N)()        if (N & 1) { ... } // A
void foo(T : int, int N)()  if (N > 3) { ... } // B
...
foo!(int, 7)();   // picks B, more specialized
foo!(int, 1)();   // picks A, as it fails B's constraint
foo!("a", 7)();   // picks A
foo!("a", 4)();   // error, no match
---

<h2>References</h2>

    $(UL
    $(LI $(LINK2 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2081.pdf, Concepts (Revision 1))
     by Douglas Gregor and Bjarne Stroustrup
    )
    )

)

Macros:
    TITLE=Template Constraints
    WIKI=Constraints
META_KEYWORDS=D Programming Language, constraints, template, concepts, C++
META_DESCRIPTION=Going beyond type patterns to constrain template instantiations.