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.typelist

This module contains the TypeList type and related metafunctions.

Authors:
Arlen Avakian

License:
Boost License 1.0

Source:
std/typelist2.d

template _and(bool A,bool B)

Boolean and.

Examples:

   static assert(_and!(true, false) == false);

template _or(bool A,bool B)

Boolean or.

Examples:

   static assert(_or!(true, false) == true);

template _not(bool A)

Boolean not.

Examples:

   static assert(_not!(false));

template _all(alias Pred,T...)

Determines if all elements of the typetuple satisfy the predicate.

Examples:

   static assert(_all!(isFloatingPoint, int, float, char) == false);

template _any(alias Pred,T...)

Determine if any element of the typetuple satisfies the predicate.

Examples:

   static assert(_any!(isFloatingPoint, int, float, char) == true);

template Id(T)

Identity metafunction.

Examples:

   static assert(Id!int == int);

template Curry(alias Fun,Args...)

Curries Fun by tying its first Args.length arguments to Args.

Examples:

   alias Curry!(_and, true) true_and;
   static assert(true_and!true == true);
   static assert(true_and!false == false);

struct TypeList(T...);

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

Examples:

   alias TypeList!(int, float, long*) TL1;
   static assert(is(TL1.items == TypeTuple!(int, float, long*)));
   static assert(TL1.dim == 1);
   static assert(is(TL1.head == int));
   static assert(is(TL1.tail == TypeList!(float, long*)));
   static assert(toString!TL1 == "[int,float,long*]");

alias items;: A typetuple of all the elements of the typelist.
alias head;: The first element of the typelist.
alias last;: The last element of the typelist.
alias tail;: The elements after the head of the typelist.
alias init;: All the elements of the typelist except the last one.
string toString();: Converts the typelist to a string representation.

template isTypeList(T)

Check to see if T is a TypeList.

template _(string TL)

Constructs a typelist. EXPERIMENTAL.

Examples:

   alias _!"[int, double, uint]" TL1;
   static assert(is(TL1 == TypeList!(int, double, uint)));

   alias _!"[[char],[float,double]]" TL2;
   static assert(is(TL2 == TypeList!(TypeList!(char), TypeList!(float, double))));

template Head(TL) if (isTypeList!(TL))

Extract the first element of a typelist.

template Last(TL) if (isTypeList!(TL))

Extract the last element of a typelist.

template Tail(TL) if (isTypeList!(TL))

Extract the elements after the head of a typelist.

template Init(TL) if (isTypeList!(TL))

Return all the elements of a typelist except the last one.

template Empty(TL) if (isTypeList!(TL))

Test whether a typelist is empty.

template Length(TL) if (isTypeList!(TL))

Returns the length of a typelist.

template Append(TL1,TL2) if (isTypeList!(TL1) && isTypeList!(TL2))

Append two typelists.

Examples:

   alias TypeList!(int) TL1;
   alias TypeList!(char) TL2;
   alias Append!(TL1, TL2) R1;
   static assert(is(R1 == TypeList!(int, char)));

template Append(TL,T) if (isTypeList!(TL) && !isTypeList!(T))

Append a type to a typelist.

Examples:

   alias TypeList!(float, double) TL1;
   alias Append!(TL1, real) R1;
   static assert(is(R1 == TypeList!(float, double, real)));

template Cons(A,B) if (isTypeList!(B))

Prepend a type to a typelist.

Examples:

   alias TypeList!(float) TL1;
   alias Cons!(char, TL1) R1;
   static assert(is(R1 == TypeList!(char, float)));

template toString(TL) if (isTypeList!(TL))

Converts a TypeList to string.

Examples:

   static assert(toString!(TypeList!(float, real)) == "[float,real]");

template sameTypes(T1,T2)

Returns true if T1 and T2 are of the same type.

template equal(alias Pred,TL1,TL2) if (isTypeList!(TL1) && isTypeList!(TL2))

Returns true if and only if the two typelists compare equal element for element, according to binary predicate Pred.

template Map(alias Fun,TL) if (isTypeList!(TL))

A new typelist is obtained by applying Fun to each item of TL.

Examples:

   alias TypeList!(immutable double, int, const char) TL1;
   alias Map!(Unqual, TL1) R1;
   static assert(is(R1 == TypeList!(double, int, char)));

template Reverse(TL) if (isTypeList!(TL))

Returns the elements of a typelist in reverse order.

Examples:

   alias TypeList!(int, double, char) TL1;
   alias Reverse!TL1 R1;
   static assert(is(R1 == TypeList!(char, double, int)));

template Intersperse(T,TL) if (isTypeList!(TL))

Intersperses T between the elements of the typelist.

Examples:

   alias TypeList!(float, double, real) TL1;
   alias Intersperse!(string, TL1) R1;
   static assert(is(R1 == TypeList!(float, string, double, string, real)));

template Transpose(TL) if (isTypeList!(TL))

Transposes the rows and columns of its argument.

Examples:

   alias TypeList!(TypeList!(float, double), TypeList!(int, long)) TL1;
   alias Transpose!(TL1) R1;
   static assert(is(R1 == TypeList!(TypeList!(float, int), TypeList!(double, long))));

template Subsequences(TL) if (isTypeList!(TL))

Returns the typelist of all subsequences of the types.

Examples:

   alias TypeList!(char, int) TL1;
   alias Subsequences!TL1 R1;
   static assert(is(R1 == TypeList!(TypeList!(), TypeList!char, TypeList!int, TypeList!(char, int))));

template Permutations(xs0) if (isTypeList!(xs0))

Returns the typelist of all permutations of the argument.

Examples:

   alias Permutations!(TypeList!(int, uint, char)) R1;
   static assert(toString!R1 == "[[int,uint,char],[uint,int,char],[char,uint,int],[uint,char,int],[char,int,uint],[int,char,uint]]");

template Foldl(alias Fun,Z,TL) if (isTypeList!(TL))

Reduces a n-dimensional typelist from left to right. Fun is the binary operator, and Z is the starting type.

Examples:

   struct C(int n) { enum cardinal = n; }

   template Minus(A, B)
   {
     alias C!(A.cardinal - B.cardinal) Minus;
   }

   alias TypeList!(C!2, C!3, C!7, C!4) TL1;
   alias Foldl!(Minus, C!0, TL1) R1;
   static assert(is(R1 == C!(-16)));

template Foldl1(alias Fun,TL) if (isTypeList!(TL))

Foldl1 is a variant of Foldl that has no starting type argument.

template Foldr(alias Fun,Z,TL) if (isTypeList!(TL))

Reduces a n-dimensional typelist from right to left. Fun is the binary operator, and Z is the starting type.

Examples:

   alias TypeList!(C!2, C!3, C!7, C!4) TL1;
   alias Foldr!(Minus, C!0, TL1) R1;
   static assert(is(R1 == C!(2)));

template Foldr1(alias Fun,TL) if (isTypeList!(TL))

Foldr1 is a variant of Foldr that has no starting type argument.

template Concat(TL) if (isTypeList!(TL))

Concatenate a typelist of typelists.

Examples:

   alias Concat!(TypeList!(TypeList!(int, uint), TypeList!char, TypeList!(long,ulong))) R1;
   static assert(is(R1 == TypeList!(int, uint, char, long, ulong)));

template ConcatMap(alias Fun,TL) if (isTypeList!(TL))

Map a metafunction over a typelist and concatenate the results.

Examples:

   template Twice(T)
   {
     alias TypeList!(T, T) Twice;
   }

   alias TypeList!(char, int, long) TL1;
   alias ConcatMap!(Twice, TL1) R1;
   static assert(is(R1 == TypeList!(char, char, int, int, long, long)));

template all(alias Pred,TL) if (isTypeList!(TL))

Determines if all elements of the typelist satisfy the predicate.

Examples:

   static assert(all!(isFloatingPoint, TypeList!(int, float, char)) == false);

template any(alias Pred,TL) if (isTypeList!(TL))

Determines if any element of the typelist satisfies the predicate.

Examples:

   static assert(any!(isFloatingPoint, TypeList!(int, float, char)) == true);

template Scanl(alias Fun,Q,TL) if (isTypeList!(TL))

Returns a n-dimensional typelist of successive reduced types from the left.

Examples:

   alias TypeList!(C!1, C!2, C!3) TL1;
   alias Scanl!(Minus, C!4, TL1) R1;
   static assert(is(R1 == TypeList!(C!4, C!3, C!1, C!(-2))));

template Scanl1(alias Fun,TL) if (isTypeList!(TL))

Scanl1 is a variant of Scanl that has no starting type argument.

template Scanr(alias Fun,Q0,TL) if (isTypeList!(TL))

Returns a n-dimensional typelist of successive reduced typess from the right.

Examples:

   alias TypeList!(C!1, C!2, C!3) TL1;
   alias Scanl!(Minus, C!4, TL1) R1;
   static assert(is(R1 == TypeList!(C!(-2), C!3, C!(-1), C!4)));

template Scanr1(alias Fun,TL) if (isTypeList!(TL))

Scanr1 is a variant of Scanr that has no starting type argument.

template IterateN(int N,alias Fun,T)

Returns a typelist of length N of repeated applications of Fun to T.

Examples:

   struct _1 { enum value = 1; }

   template TimesTwo(T)
   {
     enum string result = to!string(T.value * 2);
     mixin(xformat("struct _%1$s { enum value = %1$s; } alias _%1$s TimesTwo;", result));
   }

   alias IterateN!(6, TimesTwo, _1) R1;
   static assert(toString!R1 == "[_1,_2,_4,_8,_16,_32]");

template Replicate(int N,T)

Returns a typelist of length N with T the type of every element.

Examples:

   alias Replicate!(3, char) R1;
   static assert(is(R1 == TypeList!(char, char, char)));

template TakeN(int N,TL) if (isTypeList!(TL))

Returns the prefix of TL of length N, or TL itself if N > TL.length.

Examples:

   alias TakeN!(3, TypeList!(C!1, C!2, C!3, C!4, C!5)) R1;
   static assert(is(R1 == TypeList!(C!1, C!2, C!3)));

template TakeWhile(alias Pred,TL) if (isTypeList!(TL))

Returns the longest prefix of TL of elements that satisfy Pred.

Examples:

   alias TypeList!(int, long, char, uint, float) TL1;
   alias TakeWhile!(isIntegral, TL1) R1;
   static assert(is(R1 == TypeList!(int, long)));

template DropWhile(alias Pred,TL) if (isTypeList!(TL))

Returns the suffix remaining after TakeWhile!(Pred, TL).

Examples:

   alias TypeList!(int, uint, long, float, double, int) TL1;
   alias DropWhile!(isIntegral, TL1) R1;
   static assert(is(R1 == TypeList!(float, double, int)));

template Filter(alias Pred,TL) if (isTypeList!(TL))

Returns the typelist of those elements that satisfy the predicate.

Examples:

   alias TypeList!(int, double, uint, float, long, ulong) TL1;
   alias Filter!(isIntegral, TL1) R1;
   static assert(is(R1 == TypeList!(int, uint, long, ulong)));

template ZipWith(alias Fun,TL1,TL2) if (isTypeList!(TL1) && isTypeList!(TL2))

Takes two typelists and zips with the metafunction Fun.

Examples:

   alias TypeList!(int, char, double) TL1;
   alias TypeList!(float, long) TL2;

   alias ZipWith!(CommonType, TL1, TL2) R1;

   static assert(is(R1 == TypeList!(float, long)));

template NubBy(alias Pred,TL) if (isTypeList!(TL))

Removes duplicate elements from a typelist.

Examples:

   alias TypeList!(int, double, float, int, double, double, char) TL1;

   alias NubBy!(sameTypes, TL1) R1;

   static assert(is(R1 == TypeList!(int, double, float, char)));

template DeleteBy(alias Pred,X,TL) if (isTypeList!(TL))

Removes the first occurrence of X from its typelist argument using Pred.

Examples:

   alias TypeList!(int, float, char, double) TL1;

   alias DeleteBy!(sameTypes, float, TL1) R1;

   static assert(is(R1 == TypeList!(int, char, double)));

template UnionBy(alias Pred,TL1,TL2) if (isTypeList!(TL1) && isTypeList!(TL2))

Returns the typelist union of the two typelists.

Examples:

   alias TypeList!(int, double, float) TL1;
   alias TypeList!(char, double, int) TL2;

   alias UnionBy!(sameTypes, TL1, TL2) R1;

   static assert(is(R1 == TypeList!(int, double, float, char)));

template IntersectBy(alias Pred,TL1,TL2) if (isTypeList!(TL1) && isTypeList!(TL2))

Returns the typelist intersection of two typelists.

Examples:

   alias TypeList!(int, char, float, double) TL1;
   alias TypeList!(double, double, uint) TL2;

   alias IntersectBy!(sameTypes, TL1, TL2) R1;

   static assert(is(R1 == TypeList!(double)));

template GroupBy(alias Pred,TL) if (isTypeList!(TL))

Splits TL into a typelist of typelists. Pred provides the equality test.

Examples:

   alias TypeList!(int, int, char, float, float) TL1;

   alias GroupBy!(sameTypes, TL1) R1;

   static assert(is(R1 == TypeList!(TypeList!(int, int), TypeList!(char), TypeList!(float, float))));

template SortBy(alias Less,TL) if (isTypeList!(TL))

Returns a sorted typelist.

Examples:

   struct S1 { enum ordinal = 1; }
   struct S2 { enum ordinal = 2; }
   struct S3 { enum ordinal = 3; }
   struct S4 { enum ordinal = 4; }

   template Less(T1, T2)
   {
     static if(T1.ordinal < T2.ordinal)
       enum Less = true;
     else
       enum Less = false;
   }

   alias TypeList!(S1, S3, S2, S4, S1, S2, S4) TL1;

   alias SortBy!(Less, TL1) R1;

   static assert(is(R1 == TypeList!(S1, S1, S2, S2, S3, S4, S4)));

std

etc

core

std.typelist