Get the full package name for the given symbol.

import std.traits;
static assert(packageName!packageName == "std");

Get the module name (including package) for the given symbol.

import std.traits;
static assert(moduleName!moduleName == "std.traits");

Get the fully qualified name of a type or a symbol. Can act as an intelligent type/symbol to string converter.

module mymodule;
import std.traits;
struct MyStruct {}
static assert(fullyQualifiedName!(const MyStruct[]) == "const(mymodule.MyStruct[])");
static assert(fullyQualifiedName!fullyQualifiedName == "std.traits.fullyQualifiedName");

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. Please note that ref is not part of a type, but the attribute of the function (see template functionAttributes ).

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

Get, as a tuple, the types of the parameters to 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.

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

Returns the number of arguments of function func.  arity is undefined for variadic functions.

void foo(){}
static assert(arity!foo==0);
void bar(uint){}
static assert(arity!bar==1);

Returns a tuple consisting of the storage classes of the parameters of a function func.

alias ParameterStorageClass STC; // shorten the enum name


void func(ref int ctx, out real result, real param)
{
}
alias ParameterStorageClassTuple!func pstc;
static assert(pstc.length == 3); // three parameters

static assert(pstc[0] == STC.ref_);
static assert(pstc[1] == STC.out_);
static assert(pstc[2] == STC.none);

Get, as a tuple, the identifiers of the parameters to a function symbol.

import std.traits;
int foo(int num, string name);
static assert([ParameterIdentifierTuple!foo] == ["num", "name"]);

Get, as a tuple, the default value of the parameters to a function symbol. If a parameter doesn't have the default value, void is returned instead.

import std.traits;
int foo(int num, string name = "hello", int[] arr = [1,2,3]);
static assert(is(ParameterDefaultValueTuple!foo[0] == void));
static assert(   ParameterDefaultValueTuple!foo[1] == "hello");
static assert(   ParameterDefaultValueTuple!foo[2] == [1,2,3]);

Returns the attributes attached to a function func.

alias FunctionAttribute FA; // shorten the enum name


real func(real x) pure nothrow @safe
{
    return x;
}
static assert(functionAttributes!func & FA.pure_);
static assert(functionAttributes!func & FA.safe);
static assert(!(functionAttributes!func & FA.trusted)); // not @trusted

true if func is @safe or @trusted.

@safe    int add(int a, int b) {return a+b;}
@trusted int sub(int a, int b) {return a-b;}
@system  int mul(int a, int b) {return a*b;}

static assert( isSafe!add);
static assert( isSafe!sub);
static assert(!isSafe!mul);

true if func is @system.

@safe    int add(int a, int b) {return a+b;}
@trusted int sub(int a, int b) {return a-b;}
@system  int mul(int a, int b) {return a*b;}

static assert(!isUnsafe!add);
static assert(!isUnsafe!sub);
static assert( isUnsafe!mul);

Scheduled for deprecation in January 2013. It's badly named and provides redundant functionality. It was also badly broken prior to 2.060 (bug# 8362), so any code which uses it probably needs to be changed anyway. Please use allSatisfy(isSafe, ...) instead.

true all functions are isSafe.

@safe    int add(int a, int b) {return a+b;}
@trusted int sub(int a, int b) {return a-b;}
@system  int mul(int a, int b) {return a*b;}

static assert( areAllSafe!(add, add));
static assert( areAllSafe!(add, sub));
static assert(!areAllSafe!(sub, mul));

Returns the calling convention of function as a string.

string a = functionLinkage!(writeln!(string, int));
assert(a == "D"); // extern(D)


auto fp = &printf;
string b = functionLinkage!fp;
assert(b == "C"); // extern(C)

Determines what kind of variadic parameters function has.

void func() {}
static assert(variadicFunctionStyle!func == Variadic.no);

extern(C) int printf(in char*, ...);
static assert(variadicFunctionStyle!printf == Variadic.c);

Get the function type from a callable object func.

Using builtin typeof on a property function yields the types of the property value, not of the property function itself. Still,  FunctionTypeOf is able to obtain function types of properties.

class C
{
    int value() @property;
}
static assert(is( typeof(C.value) == int ));
static assert(is( FunctionTypeOf!(C.value) == function ));

Constructs a new function or delegate type with the same basic signature as the given one, but different attributes (including linkage).

This is especially useful for adding/removing attributes to/from types in generic code, where the actual type name cannot be spelt out.

template ExternC(T)
    if (isFunctionPointer!T || isDelegate!T || is(T == function))
{
    alias SetFunctionAttributes!(T, "C", functionAttributes!T) ExternC;
}

auto assumePure(T)(T t)
    if (isFunctionPointer!T || isDelegate!T)
{
    enum attrs = functionAttributes!T | FunctionAttribute.pure_;
    return cast(SetFunctionAttributes!(T, functionLinkage!T, attrs)) t;
}

Determines whether T has its own context pointer. T must be either class, struct, or union.

Determines whether T or any of its representation types have a context pointer.

Get as a typetuple the types of the fields of a struct, class, or union. This consists of the fields that take up memory space, excluding the hidden fields like the virtual function table pointer or a context pointer for nested types. If T isn't a struct, class, or union returns typetuple with one element T.

Get the primitive types of the fields of a struct or class, in topological order.

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

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 immutable;
2. an array U[] and U is not immutable;
3. a reference to a class or interface type C and C is not immutable.
4. an associative array that is not immutable.
5. a delegate.

Returns true if and only if T's representation includes at least one of the following:

1. a raw pointer U*;
2. an array U[];
3. a reference to a class type C.
4. an associative array.
5. a delegate.

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 immutable or shared;
2. an array U[] and U is not immutable or shared;
3. a reference to a class type C and C is not immutable or shared.
4. an associative array that is not immutable or shared.
5. a delegate that is not shared.

True if S or any type embedded directly in the representation of S defines an elaborate copy constructor. Elaborate copy constructors are introduced by defining this(this) for a struct.

Classes and unions never have elaborate copy constructors.

True if S or any type directly embedded in the representation of S defines an elaborate assignment. Elaborate assignments are introduced by defining opAssign(typeof(this)) or opAssign(ref typeof(this)) for a struct or when there is a compiler-generated opAssign (in case S has an elaborate copy constructor or destructor).

Classes and unions never have elaborate assignments.

True if S or any type directly embedded in the representation of S defines an elaborate destructor. Elaborate destructors are introduced by defining ~this() for a struct.

Classes and unions never have elaborate destructors, even though classes may define ~this().

Yields true if and only if T is an aggregate that defines a symbol called name.

Retrieves the members of an enumerated type enum E.

enum E : int { a, b, c }
int[] abc = cast(int[]) [ EnumMembers!E ];

enum Sqrts : real
{
    one   = 1,
    two   = 1.41421,
    three = 1.73205,
}
auto sqrts = [ EnumMembers!Sqrts ];
assert(sqrts == [ Sqrts.one, Sqrts.two, Sqrts.three ]);

// Returns i if e is the i-th enumerator of E.

size_t rank(E)(E e)
    if (is(E == enum))
{
    foreach (i, member; EnumMembers!E)
    {
        if (e == member)
            return i;
    }
    assert(0, "Not an enum member");
}

enum Mode
{
    read  = 1,
    write = 2,
    map   = 4,
}
assert(rank(Mode.read ) == 0);
assert(rank(Mode.write) == 1);
assert(rank(Mode.map  ) == 2);

Get a TypeTuple of the base class and base interfaces of this class or interface.  BaseTypeTuple!Object returns the empty type tuple.

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)

}

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

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)

}

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.

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)

}

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

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)

}

Returns a tuple of non-static functions with the name name declared in the class or interface C. Covariant duplicates are shrunk into the most derived one.

interface I { I foo(); }
class B
{
    real foo(real v) { return v; }
}
class C : B, I
{
    override C foo() { return this; } // covariant overriding of I.foo()

}
alias MemberFunctionsTuple!(C, "foo") foos;
static assert(foos.length == 2);
static assert(__traits(isSame, foos[0], C.foo));
static assert(__traits(isSame, foos[1], B.foo));

Returns class instance alignment.

class A { byte b; }
class B { long l; }

// As class instance always has a hidden pointer

static assert(classInstanceAlignment!A == (void*).alignof);
static assert(classInstanceAlignment!B == long.alignof);

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.

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

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.

Is From implicitly convertible to To?

Returns true iff a value of type Rhs can be assigned to a variable of type Lhs.

 isAssignable returns whether both an lvalue and rvalue can be assigned.

If you omit Rhs,  isAssignable will check identity assignable of Lhs.

    static assert( isAssignable!(long, int));
    static assert(!isAssignable!(int, long));
    static assert( isAssignable!(const(char)[], string));
    static assert(!isAssignable!(string, char[]));

    // int is assignable to int

    static assert( isAssignable!int);

    // immutable int is not assinable to immutable int

    static assert(!isAssignable!(immutable int));

Determines whether the function type F is covariant with G, i.e., functions of the type F can override ones of the type G.

interface I { I clone(); }
interface J { J clone(); }
class C : I
{
    override C clone()   // covariant overriding of I.clone()

    {
        return new C;
    }
}

// C.clone() can override I.clone(), indeed.

static assert(isCovariantWith!(typeof(C.clone), typeof(I.clone)));

// C.clone() can't override J.clone(); the return type C is not implicitly

// convertible to J.

static assert(isCovariantWith!(typeof(C.clone), typeof(J.clone)));

Creates an lvalue or rvalue of type T for typeof(...) and _traits(compiles, ...) purposes. No actual value is returned.

// Note that `f` doesn't have to be implemented

// as is isn't called.

int f(int);
bool f(ref int);
static assert(is(typeof(f(rvalueOf!int)) == int));
static assert(is(typeof(f(lvalueOf!int)) == bool));

int i = rvalueOf!int; // error, no actual value is returned

Detect whether T is a built-in boolean type.

Detect whether T is a built-in integral type. Types bool, char, wchar, and dchar are not considered integral.

Detect whether T is a built-in floating point type.

Detect whether T is a built-in numeric type (integral or floating point).

Detect whether T is a scalar type.

Detect whether T is a basic type.

Detect whether T is a built-in unsigned numeric type.

Detect whether T is a built-in signed numeric type.

Detect whether T is one of the built-in character types.

Detect whether T is one of the built-in string types.

Detect whether type T is a static array.

Detect whether type T is a dynamic array.

Detect whether type T is an array.

Detect whether T is an associative array type

Detect whether type T is a pointer.

Returns the target type of a pointer.

Scheduled for deprecation. Please use PointerTarget instead.

Detect whether type T is an aggregate type.

Returns true if T can be iterated over using a foreach loop with a single loop variable of automatically inferred type, regardless of how the foreach loop is implemented. This includes ranges, structs/classes that define opApply with a single loop variable, and builtin dynamic, static and associative arrays.

Returns true if T is not const or immutable. Note that  isMutable is true for string, or immutable(char)[], because the 'head' is mutable.

Returns true if T is an instance of the template S.

Tells whether the tuple T is an expression tuple.

Detect whether tuple T is a type tuple.

Detect whether symbol or type T is a function pointer.

Detect whether symbol or type T is a delegate.

Detect whether symbol or type T is a function, a function pointer or a delegate.

Detect whether T is a callable object, which can be called with the function call operator (...).

Detect whether T is a an abstract function.

Detect whether T is a a final function.

Determines whether function f requires a context pointer.

Detect whether T is a an abstract class.

Detect whether T is a a final class.

Removes all qualifiers, if any, from type T.

static assert(is(Unqual!int == int));
static assert(is(Unqual!(const int) == int));
static assert(is(Unqual!(immutable int) == int));
static assert(is(Unqual!(shared int) == int));
static assert(is(Unqual!(shared(const int)) == int));

Returns the inferred type of the loop variable when a variable of type T is iterated over using a foreach loop with a single loop variable and automatically inferred return type. Note that this may not be the same as std.range.ElementType!Range in the case of narrow strings, or if T has both opApply and a range interface.

Strips off all typedefs (including enum ones) from type T.

enum E : int { a }
typedef E F;
typedef const F G;
static assert(is(OriginalType!G == const int));

Get the Key type of an Associative Array.

import std.traits;
alias int[string] Hash;
static assert(is(KeyType!Hash == string));
KeyType!Hash str = "string";   // str is declared as string

Get the Value type of an Associative Array.

import std.traits;
alias int[string] Hash;
static assert(is(ValueType!Hash == int));
ValueType!Hash num = 1;   // num is declared as int

Returns the corresponding unsigned type for T. T must be a numeric integral type, otherwise a compile-time error occurs.

Returns the largest type, i.e. T such that T.sizeof is the largest. If more than one type is of the same size, the leftmost argument of these in will be returned.

Returns the corresponding signed type for T. T must be a numeric integral type, otherwise a compile-time error occurs.

Returns the most negative value of the numeric type T.

Returns the mangled name of symbol or type sth.

 mangledName is the same as builtin .mangleof property, except that the correct names of property functions are obtained.

module test;
import std.traits : mangledName;

class C
{
    int value() @property;
}
pragma(msg, C.value.mangleof);      // prints "i"

pragma(msg, mangledName!(C.value)); // prints "_D4test1C5valueMFNdZi"

Aliases itself to T[0] if the boolean condition is true and to T[1] otherwise.

    // can select types

    static assert(is(Select!(true, int, long) == int));
    static assert(is(Select!(false, int, long) == long));

    // can select symbols

    int a = 1;
    int b = 2;
    alias selA = Select!(true, a, b);
    alias selB = Select!(false, a, b);
    assert(selA == 1);
    assert(selB == 2);

If cond is true, returns a without evaluating b. Otherwise, returns b without evaluating a.