D Programming Language 2.0

- Comments
- D
- Search
- Home

Last update Sat Feb 14 12:00:09 2009

# std.traits

Templates with which to extract information about types at compile time.
Authors:
Walter Bright, Tomasz Stachowiak (isExpressionTuple), Andrei Alexandrescu

template ReturnType(alias dg)
  Get the type of the return value from a function, a pointer to function, a delegate, a struct with an opCall, a pointer to a struct with an opCall, or a class with an opCall.
  Example:

       import std.traits;
       int foo();
       ReturnType!(foo) x;   // x is declared as int

template ParameterTypeTuple(alias dg)
template ParameterTypeTuple(dg)
  Get the types of the paramters to a function, a pointer to function, or a delegate as a tuple.
  Example:

       import std.traits;
       int foo(int, long);
       void bar(ParameterTypeTuple!(foo));      // declares void bar(int, long);
       void abc(ParameterTypeTuple!(foo)[1]);   // declares void abc(long);

template FieldTypeTuple(S)
  Get the types of the fields of a struct or class. This consists of the fields that take up memory space, excluding the hidden fields like the virtual function table pointer.
template RepresentationTypeTuple(T...)
  Get the primitive types of the fields of a struct or class, in topological order.
  Example:

      struct S1 { int a; float b; }
      struct S2 { char[] a; union { S1 b; S1 * c; } }
      alias RepresentationTypeTuple!(S2) R;
      assert(R.length == 4
          && is(R[0] == char[]) && is(R[1] == int)
          && is(R[2] == float) && is(R[3] == S1*));

template hasAliasing(T...)
  Returns true if and only if T's representation includes at least one of the following:
  1. a raw pointer U* and U is not invariant;
  2. an array U[] and U is not invariant;
  3. a reference to a class type C and C is not invariant.
template BaseTypeTuple(A)
  Get a TypeTuple of the base class and base interfaces of this class or interface. BaseTypeTuple!(Object) returns the empty type tuple.
  Example:

       import std.traits, std.typetuple, std.stdio;
       interface I { }
       class A { }
       class B : A, I { }

       void main()
       {
           alias BaseTypeTuple!(B) TL;
           writeln(typeid(TL));	// prints: (A,I)
       }

template BaseClassesTuple(T)
  Get a TypeTuple of all base classes of this class, in decreasing order. Interfaces are not included. BaseClassesTuple!(Object) yields the empty type tuple.
  Example:

       import std.traits, std.typetuple, std.stdio;
       interface I { }
       class A { }
       class B : A, I { }
       class C : B { }

       void main()
       {
           alias BaseClassesTuple!(C) TL;
           writeln(typeid(TL));	// prints: (B,A,Object)
       }

template InterfacesTuple(T)
  Get a TypeTuple of all interfaces directly or indirectly inherited by this class or interface. Interfaces do not repeat if multiply implemented. InterfacesTuple!(Object) yields the empty type tuple.
  Example:

       import std.traits, std.typetuple, std.stdio;
       interface I1 { }
       interface I2 { }
       class A : I1, I2 { }
       class B : A, I1 { }
       class C : B { }

       void main()
       {
           alias InterfacesTuple!(C) TL;
           writeln(typeid(TL));	// prints: (I1, I2)
       }

template TransitiveBaseTypeTuple(T)
  Get a TypeTuple of all base classes of T, in decreasing order, followed by T's interfaces. TransitiveBaseTypeTuple!(Object) yields the empty type tuple.
  Example:

       import std.traits, std.typetuple, std.stdio;
       interface I { }
       class A { }
       class B : A, I { }
       class C : B { }

       void main()
       {
           alias TransitiveBaseTypeTuple!(C) TL;
           writeln(typeid(TL));	// prints: (B,A,Object,I)
       }

template CommonType(T...)
  Get the type that all types can be implicitly converted to. Useful e.g. in figuring out an array type from a bunch of initializing values. Returns void if passed an empty list, or if the types have no common type.
  Example:

      alias CommonType!(int, long, short) X;
      assert(is(X == long));
      alias CommonType!(int, char[], short) Y;
      assert(is(Y == void));

template ImplicitConversionTargets(T)
  Returns a tuple with all possible target types of an implicit conversion of a value of type T.
  Important note:
  The possible targets are computed more conservatively than the D 2.005 compiler does, eliminating all dangerous conversions. For example, ImplicitConversionTargets!(double) does not include float.
template isIntegral(T)
  Detect whether T is a built-in integral type
template isFloatingPoint(T)
  Detect whether T is a built-in floating point type
template isNumeric(T)
  Detect whether T is a built-in numeric type
template isSomeString(T)
  Detect whether T is one of the built-in string types
template isAssociativeArray(T)
  Detect whether T is an associative array type
template isStaticArray(T : U[N],U,size_t N)
  Detect whether type T is a static array.
template isDynamicArray(T,U = void)
  Detect whether type T is a dynamic array.
template isArray(T)
  Detect whether type T is an array.
template isExpressionTuple(T...)
  Tells whether the tuple T is an expression tuple.
template unsigned(T)
  Returns the corresponding unsigned type for T. T must be a numeric integral type, otherwise a compile-time error occurs.
template Mutable(T)
  Returns the mutable version of the type T.
template mostNegative(T)
  Returns the most negative value of the numeric type T.

Public Domain | Page generated by Ddoc.