std.traits
Templates with which to extract information about
types at compile time.
- 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;
- 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)); void abc(ParameterTypeTuple!(foo)[1]);
- 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 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)); }
- 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)); }
- 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)); }
- 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,uint 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.