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.

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

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 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...)
Evaluates to F!(T[0]) && F!(T[1]) && ... && F!(T[$ - 1]).

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

template anySatisfy(alias F,T...)
Evaluates to F!(T[0]) || F!(T[1]) || ... || F!(T[$ - 1]).

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