Improve this page Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone. Page wiki View or edit the community-maintained wiki page associated with this page.

std.typetuple

Templates with which to manipulate type tuples (also known as type lists).

Some operations on type tuples are built in to the language, such as TL[n] which gets the nth type from the type tuple. TL[lwr .. upr] returns a new type list that is a slice of the old one.

Several templates in this module use or operate on eponymous templates that take a single argument and evaluate to a boolean constant. Such templates are referred to as template predicates.

References:
Based on ideas in Table 3.1 from Modern C++ Design, Andrei Alexandrescu (Addison-Wesley Professional, 2001)

License:
Boost License 1.0.

Authors:
Walter Bright, David Nadlinger

Source:
std/typetuple.d

template TypeTuple(TList...)

Creates a typetuple out of a sequence of zero or more types.

Example:

 import std.typetuple;
 alias TypeTuple!(int, double) TL;

 int foo(TL td)  // same as int foo(int, double);
 {
    return td[0] + cast(int)td[1];
 }

Example:

 TypeTuple!(TL, char)
 // is equivalent to:
 TypeTuple!(int, double, char)

template staticIndexOf(T, TList...) template staticIndexOf(alias T, TList...)

Returns the index of the first occurrence of type T in the sequence of zero or more types TList. If not found, -1 is returned.

Example:

 import std.typetuple;
 import std.stdio;

 void foo()
 {
    writefln("The index of long is %s",
          staticIndexOf!(long, TypeTuple!(int, long, double)));
    // prints: The index of long is 1
 }

alias staticIndexOf(T, TList...) IndexOf;

Kept for backwards compatibility

template Erase(T, TList...) template Erase(alias T, TList...)

Returns a typetuple created from TList with the first occurrence, if any, of T removed.

Example:

 Erase!(long, int, long, double, char)
 // is the same as:
 TypeTuple!(int, double, char)

template EraseAll(T, TList...) template EraseAll(alias T, TList...)

Returns a typetuple created from TList with the all occurrences, if any, of T removed.

Example:

 alias TypeTuple!(int, long, long, int) TL;

 EraseAll!(long, TL)
 // is the same as:
 TypeTuple!(int, int)

template NoDuplicates(TList...)

Returns a typetuple created from TList with the all duplicate types removed.

Example:

 alias TypeTuple!(int, long, long, int, float) TL;

 NoDuplicates!(TL)
 // is the same as:
 TypeTuple!(int, long, float)

template Replace(T, U, TList...) template Replace(alias T, U, TList...) template Replace(T, alias U, TList...) template Replace(alias T, alias U, TList...)

Returns a typetuple created from TList with the first occurrence of type T, if found, replaced with type U.

Example:

 alias TypeTuple!(int, long, long, int, float) TL;

 Replace!(long, char, TL)
 // is the same as:
 TypeTuple!(int, char, long, int, float)

template ReplaceAll(T, U, TList...) template ReplaceAll(alias T, U, TList...) template ReplaceAll(T, alias U, TList...) template ReplaceAll(alias T, alias U, TList...)

Returns a typetuple created from TList with all occurrences of type T, if found, replaced with type U.

Example:

 alias TypeTuple!(int, long, long, int, float) TL;

 ReplaceAll!(long, char, TL)
 // is the same as:
 TypeTuple!(int, char, char, int, float)

template Reverse(TList...)

Returns a typetuple created from TList with the order reversed.

Example:

 alias TypeTuple!(int, long, long, int, float) TL;

 Reverse!(TL)
 // is the same as:
 TypeTuple!(float, int, long, long, int)

template MostDerived(T, TList...)

Returns the type from TList that is the most derived from type T. If none are found, T is returned.

Example:

 class A { }
 class B : A { }
 class C : B { }
 alias TypeTuple!(A, C, B) TL;

 MostDerived!(Object, TL) x;  // x is declared as type C

template DerivedToFront(TList...)

Returns the typetuple TList with the types sorted so that the most derived types come first.

Example:

 class A { }
 class B : A { }
 class C : B { }
 alias TypeTuple!(A, C, B) TL;

 DerivedToFront!(TL)
 // is the same as:
 TypeTuple!(C, B, A)

template staticMap(alias F, T...)

Evaluates to TypeTuple!(F!(T[0]), F!(T[1]), ..., F!(T[$ - 1])).

Example:

alias staticMap!(Unqual, int, const int, immutable int) T;
static assert(is(T == TypeTuple!(int, int, int)));

template allSatisfy(alias F, T...)

Tests whether all given items satisfy a template predicate, i.e. evaluates to F!(T[0]) && F!(T[1]) && ... && F!(T[$ - 1]).

Evaluation is not short-circuited if a false result is encountered; the template predicate must be instantiable with all the given items.

Example:

static assert(!allSatisfy!(isIntegral, int, double));
static assert(allSatisfy!(isIntegral, int, long));

template anySatisfy(alias F, T...)

Tests whether all given items satisfy a template predicate, i.e. evaluates to F!(T[0]) || F!(T[1]) || ... || F!(T[$ - 1]).

Evaluation is not short-circuited if a true result is encountered; the template predicate must be instantiable with all the given items.

Example:

static assert(!anySatisfy!(isIntegral, string, double));
static assert(anySatisfy!(isIntegral, int, double));

template Filter(alias pred, TList...)

Filters a TypeTuple using a template predicate. Returns a TypeTuple of the elements which satisfy the predicate.

Examples:

static assert(is(Filter!(isNarrowString, string, wstring,
                         dchar[], char[], dstring, int) ==
                 TypeTuple!(string, wstring, char[])));
static assert(is(Filter!(isUnsigned, int, byte, ubyte,
                         dstring, dchar, uint, ulong) ==
                 TypeTuple!(ubyte, uint, ulong)));

template templateNot(alias pred)

Negates the passed template predicate.

Examples:

 alias templateNot!isPointer isNoPointer;
 static assert(!isNoPointer!(int*));
 static assert(allSatisfy!(isNoPointer, string, char, float));

template templateAnd(Preds...)

Combines several template predicates using logical AND, i.e. constructs a new predicate which evaluates to true for a given input T if and only if all of the passed predicates are true for T.

The predicates are evaluated from left to right, aborting evaluation in a short-cut manner if a false result is encountered, in which case the latter instantiations do not need to compile.

Examples:

 alias templateAnd!(isNumeric, templateNot!isUnsigned) storesNegativeNumbers;
 static assert(storesNegativeNumbers!int);
 static assert(!storesNegativeNumbers!string && !storesNegativeNumbers!uint);

 // An empty list of predicates always yields true.
 alias templateAnd!() alwaysTrue;
 static assert(alwaysTrue!int);

template templateOr(Preds...)

Combines several template predicates using logical OR, i.e. constructs a new predicate which evaluates to true for a given input T if and only at least one of the passed predicates is true for T.

The predicates are evaluated from left to right, aborting evaluation in a short-cut manner if a true result is encountered, in which case the latter instantiations do not need to compile.

Examples:

 alias templateOr!(isPointer, isUnsigned) isPtrOrUnsigned;
 static assert(isPtrOrUnsigned!uint && isPtrOrUnsigned!(short*));
 static assert(!isPtrOrUnsigned!int && !isPtrOrUnsigned!string);

 // An empty list of predicates never yields true.
 alias templateOr!() alwaysFalse;
 static assert(!alwaysFalse!int);

std

etc

core

std.typetuple