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.
Examples:
import std.typetuple; alias TL = TypeTuple!(int, double); int foo(TL td) // same as int foo(int, double); { return td[0] + cast(int)td[1]; }
Examples:alias TL = TypeTuple!(int, double); alias Types = TypeTuple!(TL, char); static assert(is(Types == 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.
Examples:
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 = staticIndexOf(T, TList...);
- 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.
Examples:
alias Types = TypeTuple!(int, long, double, char); alias TL = Erase!(long, Types); static assert(is(TL == 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.
Examples:
alias Types = TypeTuple!(int, long, long, int); alias TL = EraseAll!(long, Types); static assert(is(TL == TypeTuple!(int, int)));
- template NoDuplicates(TList...)
- Returns a typetuple created from TList with the all duplicate
types removed.
Examples:
alias Types = TypeTuple!(int, long, long, int, float); alias TL = NoDuplicates!(Types); static assert(is(TL == 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.
Examples:
alias Types = TypeTuple!(int, long, long, int, float); alias TL = Replace!(long, char, Types); static assert(is(TL == 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.
Examples:
alias Types = TypeTuple!(int, long, long, int, float); alias TL = ReplaceAll!(long, char, Types); static assert(is(TL == TypeTuple!(int, char, char, int, float)));
- template Reverse(TList...)
- Returns a typetuple created from TList with the order reversed.
Examples:
alias Types = TypeTuple!(int, long, long, int, float); alias TL = Reverse!(Types); static assert(is(TL == 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.
Examples:
class A { } class B : A { } class C : B { } alias Types = TypeTuple!(A, C, B); MostDerived!(Object, Types) x; // x is declared as type C static assert(is(typeof(x) == C));
- template DerivedToFront(TList...)
- Returns the typetuple TList with the types sorted so that the most
derived types come first.
Examples:
class A { } class B : A { } class C : B { } alias Types = TypeTuple!(A, C, B); alias TL = DerivedToFront!(Types); static assert(is(TL == TypeTuple!(C, B, A)));
- template staticMap(alias F, T...)
- Evaluates to TypeTuple!(F!(T[0]), F!(T[1]), ..., F!(T[$ - 1])).
Examples:
alias TL = staticMap!(Unqual, int, const int, immutable int); static assert(is(TL == 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.
Examples:
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.
Examples:
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:
alias Types1 = TypeTuple!(string, wstring, dchar[], char[], dstring, int); alias TL1 = Filter!(isNarrowString, Types1); static assert(is(TL1 == TypeTuple!(string, wstring, char[]))); alias Types2 = TypeTuple!(int, byte, ubyte, dstring, dchar, uint, ulong); alias TL2 = Filter!(isUnsigned, Types2); static assert(is(TL2 == TypeTuple!(ubyte, uint, ulong)));
- template templateNot(alias pred)
- Negates the passed template predicate.
Examples:
import std.traits; alias isNoPointer = templateNot!isPointer; 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 storesNegativeNumbers = templateAnd!(isNumeric, templateNot!isUnsigned); static assert(storesNegativeNumbers!int); static assert(!storesNegativeNumbers!string && !storesNegativeNumbers!uint); // An empty list of predicates always yields true. alias alwaysTrue = templateAnd!(); 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 isPtrOrUnsigned = templateOr!(isPointer, isUnsigned); static assert( isPtrOrUnsigned!uint && isPtrOrUnsigned!(short*)); static assert(!isPtrOrUnsigned!int && !isPtrOrUnsigned!(string)); // An empty list of predicates never yields true. alias alwaysFalse = templateOr!(); static assert(!alwaysFalse!int);