D Programming Language 2.0

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

  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);

Copyright Digital Mars 2005 - 2009. | Page generated by Ddoc.