If you spot a problem with this page, click here to create a Bugzilla issue.

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 a local clone.

std.traits

Templates which extract information about types and symbols at compile time.


Category	Templates
Symbol Name traits	fullyQualifiedName mangledName moduleName packageName
Function traits	isFunction arity functionAttributes hasFunctionAttributes functionLinkage FunctionTypeOf isSafe isUnsafe isFinal ParameterDefaults ParameterIdentifierTuple ParameterStorageClassTuple Parameters ReturnType SetFunctionAttributes variadicFunctionStyle
Aggregate Type traits	BaseClassesTuple BaseTypeTuple classInstanceAlignment EnumMembers FieldNameTuple Fields hasAliasing hasElaborateAssign hasElaborateCopyConstructor hasElaborateDestructor hasElaborateMove hasIndirections hasMember hasStaticMember hasNested hasUnsharedAliasing InterfacesTuple isInnerClass isNested MemberFunctionsTuple RepresentationTypeTuple TemplateArgsOf TemplateOf TransitiveBaseTypeTuple
Type Conversion	CommonType AllImplicitConversionTargets ImplicitConversionTargets CopyTypeQualifiers CopyConstness isAssignable isCovariantWith isImplicitlyConvertible isQualifierConvertible
Type Constructors	InoutOf ConstOf SharedOf SharedInoutOf SharedConstOf SharedConstInoutOf ImmutableOf QualifierOf
Categories of types	allSameType ifTestable isType isAggregateType isArray isAssociativeArray isAutodecodableString isBasicType isBoolean isBuiltinType isCopyable isDynamicArray isEqualityComparable isFloatingPoint isIntegral isNarrowString isConvertibleToString isNumeric isOrderingComparable isPointer isScalarType isSigned isSIMDVector isSomeChar isSomeString isStaticArray isUnsigned
Type behaviours	isAbstractClass isAbstractFunction isCallable isDelegate isExpressions isFinalClass isFinalFunction isFunctionPointer isInstanceOf isIterable isMutable isSomeFunction isTypeTuple
General Types	ForeachType KeyType Largest mostNegative OriginalType PointerTarget Signed Unconst Unshared Unqual Unsigned ValueType Promoted
Misc	lvalueOf rvalueOf Select select
User-Defined Attributes	hasUDA getUDAs getSymbolsByUDA

License:

Boost License 1.0.

Authors:

Walter Bright, Tomasz Stachowiak (isExpressions), Andrei Alexandrescu, Shin Fujishiro, Robert Clipsham, David Nadlinger, Kenji Hara, Shoichi Kato

Source std/traits.d

template InoutOf(T)

Parameters:

T	The type to qualify

Returns:

T with the inout qualifier added.

Examples:

static assert(is(InoutOf!(int) == inout int));
static assert(is(InoutOf!(inout int) == inout int));
static assert(is(InoutOf!(const int) == inout const int));
static assert(is(InoutOf!(shared int) == inout shared int));

template ConstOf(T)

Parameters:

T	The type to qualify

Returns:

T with the const qualifier added.

Examples:

static assert(is(ConstOf!(int) == const int));
static assert(is(ConstOf!(const int) == const int));
static assert(is(ConstOf!(inout int) == const inout int));
static assert(is(ConstOf!(shared int) == const shared int));

template SharedOf(T)

Parameters:

T	The type to qualify

Returns:

T with the shared qualifier added.

Examples:

static assert(is(SharedOf!(int) == shared int));
static assert(is(SharedOf!(shared int) == shared int));
static assert(is(SharedOf!(inout int) == shared inout int));
static assert(is(SharedOf!(immutable int) == shared immutable int));

template SharedInoutOf(T)

Parameters:

T	The type to qualify

Returns:

T with the inout and shared qualifiers added.

Examples:

static assert(is(SharedInoutOf!(int) == shared inout int));
static assert(is(SharedInoutOf!(int) == inout shared int));

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

template SharedConstOf(T)

Parameters:

T	The type to qualify

Returns:

T with the const and shared qualifiers added.

Examples:

static assert(is(SharedConstOf!(int) == shared const int));
static assert(is(SharedConstOf!(int) == const shared int));

static assert(is(SharedConstOf!(inout int) == shared inout const int));
// immutable variables are implicitly shared and const
static assert(is(SharedConstOf!(immutable int) == immutable int));

template SharedConstInoutOf(T)

Parameters:

T	The type to qualify

Returns:

T with the const, shared, and inout qualifiers added.

Examples:

static assert(is(SharedConstInoutOf!(int) == shared const inout int));
static assert(is(SharedConstInoutOf!(int) == const shared inout int));
static assert(is(SharedConstInoutOf!(inout int) == shared inout const int));
// immutable variables are implicitly shared and const
static assert(is(SharedConstInoutOf!(immutable int) == immutable int));

template ImmutableOf(T)

Parameters:

T	The type to qualify

Returns:

T with the immutable qualifier added.

Examples:

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

template QualifierOf(T)

Gives a template that can be used to apply the same attributes that are on the given type T. E.g. passing inout shared int will return SharedInoutOf.

Parameters:

T	the type to check qualifiers from

Returns:

The qualifier template from the given type T

Examples:

static assert(__traits(isSame, QualifierOf!(shared const inout int), SharedConstInoutOf));
static assert(__traits(isSame, QualifierOf!(immutable int), ImmutableOf));
static assert(__traits(isSame, QualifierOf!(shared int), SharedOf));
static assert(__traits(isSame, QualifierOf!(shared inout int), SharedInoutOf));
import std.meta : Alias;
static assert(__traits(isSame, QualifierOf!(int), Alias));

template packageName(alias T)

Get the full package name for the given symbol.

Examples:

static assert(packageName!packageName == "std");

Examples:

static assert(packageName!moduleName == "std");

template moduleName(alias T)

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

Examples:

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

enum auto fullyQualifiedName(T); enum auto fullyQualifiedName(alias T);

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

Example

module myModule;
struct MyStruct {}
static assert(fullyQualifiedName!(const MyStruct[]) == "const(myModule.MyStruct[])");

Examples:

static assert(fullyQualifiedName!fullyQualifiedName == "std.traits.fullyQualifiedName");

template ReturnType(alias func) if (isCallable!func)

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

Note: To reduce template instantiations, consider instead using typeof(() { return func(args); } ()) if the argument types are known or static if (is(typeof(func) Ret == return)) if only that basic test is needed.

Examples:

int foo();
ReturnType!foo x;   // x is declared as int

template Parameters(alias func) if (isCallable!func)

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.

Examples:

int foo(int, long);
void bar(Parameters!foo);      // declares void bar(int, long);
void abc(Parameters!foo[1]);   // declares void abc(long);

alias ParameterTypeTuple = Parameters(alias func) if (isCallable!func);

Alternate name for Parameters, kept for legacy compatibility.

template arity(alias func) if (isCallable!func && (variadicFunctionStyle!func == Variadic.no))

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

Examples:

void foo(){}
static assert(arity!foo == 0);
void bar(uint){}
static assert(arity!bar == 1);
void variadicFoo(uint...){}
static assert(!__traits(compiles, arity!variadicFoo));

enum ParameterStorageClass: uint; template ParameterStorageClassTuple(alias func) if (isCallable!func)

Get a tuple of the storage classes of a function's parameters.

Parameters:

func	function symbol or type of function, delegate, or pointer to function

Returns:

A tuple of ParameterStorageClass bits

Examples:

alias STC = ParameterStorageClass; // shorten the enum name

void func(ref int ctx, out real result, in real param, void* ptr)
{
}
alias pstc = ParameterStorageClassTuple!func;
static assert(pstc.length == 4); // number of parameters
static assert(pstc[0] == STC.ref_);
static assert(pstc[1] == STC.out_);
version (none)
{
    // TODO: When the DMD PR (dlang/dmd#11474) gets merged,
    // remove the versioning and the second test
    static assert(pstc[2] == STC.in_);
    // This is the current behavior, before `in` is fixed to not be an alias
    static assert(pstc[2] == STC.scope_);
}
static assert(pstc[3] == STC.none);

none in_ ref_ out_ lazy_ scope_ return_: These flags can be bitwise OR-ed together to represent complex storage class.

enum ParameterStorageClass extractParameterStorageClassFlags(Attribs...);

Convert the result of __traits(getParameterStorageClasses) to ParameterStorageClass enums.

Parameters:

Attribs

The return value of __traits(getParameterStorageClasses)

Returns:

The bitwise OR of the equivalent ParameterStorageClass enums.

Examples:

static void func(ref int ctx, out real result);

enum param1 = extractParameterStorageClassFlags!(
    __traits(getParameterStorageClasses, func, 0)
);
static assert(param1 == ParameterStorageClass.ref_);

enum param2 = extractParameterStorageClassFlags!(
    __traits(getParameterStorageClasses, func, 1)
);
static assert(param2 == ParameterStorageClass.out_);

enum param3 = extractParameterStorageClassFlags!(
    __traits(getParameterStorageClasses, func, 0),
    __traits(getParameterStorageClasses, func, 1)
);
static assert(param3 == (ParameterStorageClass.ref_ | ParameterStorageClass.out_));

template ParameterIdentifierTuple(alias func) if (isCallable!func)

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

Examples:

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

template ParameterDefaults(alias func) if (isCallable!func)

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

Examples:

int foo(int num, string name = "hello", int[] = [1,2,3], lazy int x = 0);
static assert(is(ParameterDefaults!foo[0] == void));
static assert(   ParameterDefaults!foo[1] == "hello");
static assert(   ParameterDefaults!foo[2] == [1,2,3]);
static assert(   ParameterDefaults!foo[3] == 0);

alias ParameterDefaultValueTuple = ParameterDefaults(alias func) if (isCallable!func);

Alternate name for ParameterDefaults, kept for legacy compatibility.

enum FunctionAttribute: uint; template functionAttributes(alias func) if (isCallable!func)

Returns the FunctionAttribute mask for function func.

See Also:

hasFunctionAttributes

Examples:

alias FA = FunctionAttribute; // 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

none pure_ nothrow_ ref_ property trusted safe nogc system const_ immutable_ inout_ shared_ return_ scope_ live: These flags can be bitwise OR-ed together to represent a complex attribute.

template hasFunctionAttributes(args...) if (args.length > 0 && isCallable!(args[0]) && allSatisfy!(isSomeString, typeof(args[1..$])))

Checks whether a function has the given attributes attached.

Parameters:

args	Function to check, followed by a variadic number of function attributes as strings

Returns:

true, if the function has the list of attributes attached and false otherwise.

See Also:

functionAttributes

Examples:

real func(real x) pure nothrow @safe;
static assert(hasFunctionAttributes!(func, "@safe", "pure"));
static assert(!hasFunctionAttributes!(func, "@trusted"));

// for templates attributes are automatically inferred
bool myFunc(T)(T b)
{
    return !b;
}
static assert(hasFunctionAttributes!(myFunc!bool, "@safe", "pure", "@nogc", "nothrow"));
static assert(!hasFunctionAttributes!(myFunc!bool, "shared"));

template isSafe(alias func) if (isCallable!func)

true if func is @safe or @trusted.

Examples:

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

enum auto isUnsafe(alias func);

true if func is @system.

Examples:

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

template functionLinkage(alias func) if (isCallable!func)

Determine the linkage attribute of the function.

Parameters:

func	the function symbol, or the type of a function, delegate, or pointer to function

Returns:

one of the strings "D", "C", "C++", "Windows", "Objective-C", or "System".

Examples:

extern(D) void Dfunc() {}
extern(C) void Cfunc() {}
static assert(functionLinkage!Dfunc == "D");
static assert(functionLinkage!Cfunc == "C");

string a = functionLinkage!Dfunc;
writeln(a); // "D"

auto fp = &Cfunc;
string b = functionLinkage!fp;
writeln(b); // "C"

enum Variadic: int; template variadicFunctionStyle(alias func) if (isCallable!func)

Determines what kind of variadic parameters function has.

Parameters:

func	function symbol or type of function, delegate, or pointer to function

Returns:

enum Variadic

Examples:

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

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

no: Function is not variadic.
c: Function is a C-style variadic function, which uses core.stdc.stdarg
d: Function is a D-style variadic function, which uses __argptr and __arguments.
typesafe: Function is a typesafe variadic function.

template FunctionTypeOf(alias func) if (isCallable!func)

Get the function type from a callable object func, or from a function pointer/delegate type.

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.

Note Do not confuse function types with function pointer types; function types are usually used for compile-time reflection purposes.

Examples:

class C
{
    int value() @property => 0;
    static string opCall() => "hi";
}
static assert(is( typeof(C.value) == int ));
static assert(is( FunctionTypeOf!(C.value) == function ));
static assert(is( FunctionTypeOf!C == typeof(C.opCall) ));

int function() fp;
alias IntFn = int();
static assert(is( typeof(fp) == IntFn* ));
static assert(is( FunctionTypeOf!fp == IntFn ));

template SetFunctionAttributes(T, string linkage, uint attrs) if (isFunctionPointer!T || isDelegate!T) template SetFunctionAttributes(T, string linkage, uint attrs) if (is(T == 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.

Parameters:

T	The base type.
linkage	The desired linkage of the result type.
attrs	The desired FunctionAttributes of the result type.

Examples:

alias ExternC(T) = SetFunctionAttributes!(T, "C", functionAttributes!T);

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

int f()
{
    import core.thread : getpid;
    return getpid();
}

int g() pure @trusted
{
    auto pureF = assumePure(&f);
    return pureF();
}
assert(g() > 0);

template isInnerClass(T) if (is(T == class))

Determines whether T is a class nested inside another class and that T.outer is the implicit reference to the outer class (i.e. outer has not been used as a field or method name)

Parameters:

T	type to test

Returns:

true if T is a class nested inside another, with the conditions described above; false otherwise

Examples:

class C
{
    int outer;
}
static assert(!isInnerClass!C);

class Outer1
{
    class Inner1 { }
    class Inner2
    {
        int outer;
    }
}
static assert(isInnerClass!(Outer1.Inner1));
static assert(!isInnerClass!(Outer1.Inner2));

static class Outer2
{
    static class Inner
    {
        int outer;
    }
}
static assert(!isInnerClass!(Outer2.Inner));

template isNested(T) if (is(T == class) || is(T == struct) || is(T == union))

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

See Also:

isImplicitlyConvertible

Examples:

import std.meta : AliasSeq;

static assert(is(AllImplicitConversionTargets!(ulong) == AliasSeq!(long, float, double, real)));
static assert(is(AllImplicitConversionTargets!(int) == AliasSeq!(dchar, uint, long, ulong, float, double, real)));
static assert(is(AllImplicitConversionTargets!(float) == AliasSeq!(double, real)));
static assert(is(AllImplicitConversionTargets!(double) == AliasSeq!(float, real)));

static assert(is(AllImplicitConversionTargets!(char) ==
    AliasSeq!(byte, ubyte, short, ushort, wchar, int, dchar, uint, long,
        ulong, float, double, real)
));
static assert(is(AllImplicitConversionTargets!(wchar) == AliasSeq!(
    short, ushort, dchar, int, uint, long, ulong, float, double, real
)));
static assert(is(AllImplicitConversionTargets!(dchar) == AliasSeq!(
    int, uint, long, ulong, float, double, real
)));

static assert(is(AllImplicitConversionTargets!(string) == AliasSeq!(const(char)[])));
static assert(is(AllImplicitConversionTargets!(int*) == AliasSeq!(void*)));

interface A {}
interface B {}
class C : A, B {}

static assert(is(AllImplicitConversionTargets!(C) == AliasSeq!(Object, A, B)));
static assert(is(AllImplicitConversionTargets!(const C) == AliasSeq!(const Object, const A, const B)));
static assert(is(AllImplicitConversionTargets!(immutable C) == AliasSeq!(
    immutable Object, immutable A, immutable B
)));

interface I : A, B {}

static assert(is(AllImplicitConversionTargets!(I) == AliasSeq!(A, B)));
static assert(is(AllImplicitConversionTargets!(const I) == AliasSeq!(const A, const B)));
static assert(is(AllImplicitConversionTargets!(immutable I) == AliasSeq!(
    immutable A, immutable B
)));

template ImplicitConversionTargets(T)

Parameters:

T	The type to check

Warning This template is considered out-dated. It will be removed from Phobos in 2.107.0. Please use AllImplicitConversionTargets instead.

Returns:

An std.meta.AliasSeq with all possible target types of an implicit conversion T.

If T is a class derived from Object, the result of TransitiveBaseTypeTuple is returned.

If the type is not a built-in value type or a class derived from Object, an empty std.meta.AliasSeq is returned.

Note The possible targets are computed more conservatively than the language allows, eliminating all dangerous conversions. For example, ImplicitConversionTargets!double does not include float.

See Also:

isImplicitlyConvertible

enum bool isImplicitlyConvertible(From, To);

Is From implicitly convertible to To?

Examples:

static assert( isImplicitlyConvertible!(immutable(char), char));
static assert( isImplicitlyConvertible!(const(char), char));
static assert( isImplicitlyConvertible!(char, wchar));
static assert(!isImplicitlyConvertible!(wchar, char));

static assert(!isImplicitlyConvertible!(const(ushort), ubyte));
static assert(!isImplicitlyConvertible!(const(uint), ubyte));
static assert(!isImplicitlyConvertible!(const(ulong), ubyte));

static assert(!isImplicitlyConvertible!(const(char)[], string));
static assert( isImplicitlyConvertible!(string, const(char)[]));

enum bool isQualifierConvertible(From, To);

Is From qualifier-convertible to To?

Examples:

// Mutable and immmutable both convert to const...
static assert( isQualifierConvertible!(char, const(char)));
static assert( isQualifierConvertible!(immutable(char), const(char)));
// ...but const does not convert back to mutable or immutable
static assert(!isQualifierConvertible!(const(char), char));
static assert(!isQualifierConvertible!(const(char), immutable(char)));

enum auto isAssignable(Lhs, Rhs = Lhs);

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.

Examples:

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 assignable to immutable int
static assert(!isAssignable!(immutable int));

enum auto isRvalueAssignable(Lhs, Rhs = Lhs);

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

Examples:

struct S1
{
    void opAssign(S1);
}

struct S2
{
    void opAssign(ref S2);
}

static assert( isRvalueAssignable!(long, int));
static assert(!isRvalueAssignable!(int, long));
static assert( isRvalueAssignable!S1);
static assert(!isRvalueAssignable!S2);

enum auto isLvalueAssignable(Lhs, Rhs = Lhs);

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

Examples:

struct S1
{
    void opAssign(S1);
}

struct S2
{
    void opAssign(ref S2);
}

static assert( isLvalueAssignable!(long, int));
static assert(!isLvalueAssignable!(int, long));
static assert( isLvalueAssignable!S1);
static assert( isLvalueAssignable!S2);

template isCovariantWith(F, G) if (is(F == function) && is(G == function) || is(F == delegate) && is(G == delegate) || isFunctionPointer!F && isFunctionPointer!G)

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

Examples:

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

@property T rvalueOf(T)(inout __InoutWorkaroundStruct = __InoutWorkaroundStruct.init); @property ref T lvalueOf(T)(inout __InoutWorkaroundStruct = __InoutWorkaroundStruct.init);

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

Parameters:

T	The type to transform

Note Trying to use returned value will result in a "Symbol Undefined" error at link time.

Examples:

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

Examples:

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

enum bool isBoolean(T);

Detect whether T is a built-in boolean type or enum of boolean base type.

Examples:

static assert( isBoolean!bool);
enum EB : bool { a = true }
static assert( isBoolean!EB);

struct SubTypeOfBool
{
    bool val;
    alias val this;
}
static assert(!isBoolean!(SubTypeOfBool));

template isIntegral(T)

Detect whether T is a built-in integral type. Integral types are byte, ubyte, short, ushort, int, uint, long, ulong, cent, ucent, and enums with an integral type as its base type.

Parameters:

T	type to test

Returns:

true if T is an integral type

Note this is not the same as __traits(isIntegral)

Examples:

static assert(
    isIntegral!byte &&
    isIntegral!short &&
    isIntegral!int &&
    isIntegral!long &&
    isIntegral!(const(long)) &&
    isIntegral!(immutable(long))
);

static assert(
    !isIntegral!bool &&
    !isIntegral!char &&
    !isIntegral!double
);

// types which act as integral values do not pass
struct S
{
    int val;
    alias val this;
}

static assert(!isIntegral!S);

enum bool isFloatingPoint(T);

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

See Also:

isTypeTuple.

Examples:

static assert(isExpressions!(1, 2.0, "a"));
static assert(!isExpressions!(int, double, string));
static assert(!isExpressions!(int, 2.0, "a"));

alias isExpressionTuple = isExpressions(T...);

Alternate name for isExpressions, kept for legacy compatibility.

enum auto isTypeTuple(T...);

Check whether the tuple T is a type tuple. A type tuple only contains types.

See Also:

isExpressions.

Examples:

static assert(isTypeTuple!(int, float, string));
static assert(!isTypeTuple!(1, 2.0, "a"));
static assert(!isTypeTuple!(1, double, string));

enum bool isFunctionPointer(alias T);

Detect whether symbol or type T is a function pointer.

Examples:

static void foo() {}
void bar() {}

auto fpfoo = &foo;
static assert( isFunctionPointer!fpfoo);
static assert( isFunctionPointer!(void function()));

auto dgbar = &bar;
static assert(!isFunctionPointer!dgbar);
static assert(!isFunctionPointer!(void delegate()));
static assert(!isFunctionPointer!foo);
static assert(!isFunctionPointer!bar);

static assert( isFunctionPointer!((int a) {}));

enum bool isDelegate(alias T);

Detect whether symbol or type T is a delegate.

Examples:

static void sfunc() { }
int x;
void func() { x++; }

int delegate() dg;
assert(isDelegate!dg);
assert(isDelegate!(int delegate()));
assert(isDelegate!(typeof(&func)));

int function() fp;
assert(!isDelegate!fp);
assert(!isDelegate!(int function()));
assert(!isDelegate!(typeof(&sfunc)));

enum bool isSomeFunction(alias T);

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

Parameters:

T	The type to check

Returns:

A bool

Examples:

static real func(ref int) { return 0; }
static void prop() @property { }
class C
{
    real method(ref int) { return 0; }
    real prop() @property { return 0; }
}
auto c = new C;
auto fp = &func;
auto dg = &c.method;

static assert( isSomeFunction!func);
static assert( isSomeFunction!prop);
static assert( isSomeFunction!(C.method));
static assert( isSomeFunction!(C.prop));
static assert( isSomeFunction!(c.prop));
static assert( isSomeFunction!fp);
static assert( isSomeFunction!dg);

real val;
static assert(!isSomeFunction!int);
static assert(!isSomeFunction!val);

template isCallable(alias callable)

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

Examples:

Functions, lambdas, and aggregate types with (static) opCall.

void f() { }
int g(int x) { return x; }

static assert( isCallable!f);
static assert( isCallable!g);

class C { int opCall(int) { return 0; } }
auto c = new C;
struct S { static int opCall(int) { return 0; } }
interface I { real value() @property; }

static assert( isCallable!c);
static assert( isCallable!(c.opCall));
static assert( isCallable!S);
static assert( isCallable!(I.value));
static assert( isCallable!((int a) { return a; }));

static assert(!isCallable!I);

Examples:

Templates

void f()() { }
T g(T = int)(T x) { return x; }
struct S1 { static void opCall()() { } }
struct S2 { static T opCall(T = int)(T x) {return x; } }

static assert( isCallable!f);
static assert( isCallable!g);
static assert( isCallable!S1);
static assert( isCallable!S2);

Examples:

Overloaded functions and function templates.

static struct Wrapper
{
    void f() { }
    int f(int x) { return x; }

    void g()() { }
    T g(T = int)(T x) { return x; }
}

static assert(isCallable!(Wrapper.f));
static assert(isCallable!(Wrapper.g));

enum auto isAbstractFunction(alias S);

Detect whether S is an abstract function.

Parameters:

S	The symbol to check

Returns:

A bool

Examples:

struct S { void foo() { } }
class C { void foo() { } }
class AC { abstract void foo(); }
static assert(!isAbstractFunction!(int));
static assert(!isAbstractFunction!(S.foo));
static assert(!isAbstractFunction!(C.foo));
static assert( isAbstractFunction!(AC.foo));

enum auto isFinalFunction(alias S);

Detect whether S is a final function.

Examples:

struct S { void bar() { } }
final class FC { void foo(); }
class C
{
    void bar() { }
    final void foo();
}
static assert(!isFinalFunction!(int));
static assert(!isFinalFunction!(S.bar));
static assert( isFinalFunction!(FC.foo));
static assert(!isFinalFunction!(C.bar));
static assert( isFinalFunction!(C.foo));

enum auto isNestedFunction(alias f);

Determines if f is a function that requires a context pointer.

Parameters:

f	The type to check Returns A bool

Examples:

static void f() {}
static void fun()
{
    int i;
    int f() { return i; }

    static assert(isNestedFunction!(f));
}

static assert(!isNestedFunction!f);

enum auto isAbstractClass(alias S);

Detect whether S is an abstract class.

Examples:

struct S { }
class C { }
abstract class AC { }
static assert(!isAbstractClass!S);
static assert(!isAbstractClass!C);
static assert( isAbstractClass!AC);
C c;
static assert(!isAbstractClass!c);
AC ac;
static assert( isAbstractClass!ac);

enum auto isFinalClass(alias S);

Detect whether S is a final class.

See Also:

getUDAs

Examples:

enum E;
struct S {}

@("alpha") int a;
static assert(hasUDA!(a, "alpha"));
static assert(!hasUDA!(a, S));
static assert(!hasUDA!(a, E));

@(E) int b;
static assert(!hasUDA!(b, "alpha"));
static assert(!hasUDA!(b, S));
static assert(hasUDA!(b, E));

@E int c;
static assert(!hasUDA!(c, "alpha"));
static assert(!hasUDA!(c, S));
static assert(hasUDA!(c, E));

@(S, E) int d;
static assert(!hasUDA!(d, "alpha"));
static assert(hasUDA!(d, S));
static assert(hasUDA!(d, E));

@S int e;
static assert(!hasUDA!(e, "alpha"));
static assert(hasUDA!(e, S));
static assert(!hasUDA!(e, S()));
static assert(!hasUDA!(e, E));

@S() int f;
static assert(!hasUDA!(f, "alpha"));
static assert(hasUDA!(f, S));
static assert(hasUDA!(f, S()));
static assert(!hasUDA!(f, E));

@(S, E, "alpha") int g;
static assert(hasUDA!(g, "alpha"));
static assert(hasUDA!(g, S));
static assert(hasUDA!(g, E));

@(100) int h;
static assert(hasUDA!(h, 100));

struct Named { string name; }

@Named("abc") int i;
static assert(hasUDA!(i, Named));
static assert(hasUDA!(i, Named("abc")));
static assert(!hasUDA!(i, Named("def")));

struct AttrT(T)
{
    string name;
    T value;
}

@AttrT!int("answer", 42) int j;
static assert(hasUDA!(j, AttrT));
static assert(hasUDA!(j, AttrT!int));
static assert(!hasUDA!(j, AttrT!string));

@AttrT!string("hello", "world") int k;
static assert(hasUDA!(k, AttrT));
static assert(!hasUDA!(k, AttrT!int));
static assert(hasUDA!(k, AttrT!string));

struct FuncAttr(alias f) { alias func = f; }
static int fourtyTwo() { return 42; }
static size_t getLen(string s) { return s.length; }

@FuncAttr!getLen int l;
static assert(hasUDA!(l, FuncAttr));
static assert(!hasUDA!(l, FuncAttr!fourtyTwo));
static assert(hasUDA!(l, FuncAttr!getLen));
static assert(!hasUDA!(l, FuncAttr!fourtyTwo()));
static assert(!hasUDA!(l, FuncAttr!getLen()));

@FuncAttr!getLen() int m;
static assert(hasUDA!(m, FuncAttr));
static assert(!hasUDA!(m, FuncAttr!fourtyTwo));
static assert(hasUDA!(m, FuncAttr!getLen));
static assert(!hasUDA!(m, FuncAttr!fourtyTwo()));
static assert(hasUDA!(m, FuncAttr!getLen()));

template getUDAs(alias symbol, alias attribute)

Gets the matching user-defined attributes from the given symbol.

If the UDA is a type, then any UDAs of the same type on the symbol will match. If the UDA is a template for a type, then any UDA which is an instantiation of that template will match. And if the UDA is a value, then any UDAs on the symbol which are equal to that value will match.

See Also:

hasUDA

Examples:

struct Attr
{
    string name;
    int value;
}

@Attr("Answer", 42) int a;
static assert(getUDAs!(a, Attr).length == 1);
static assert(getUDAs!(a, Attr)[0].name == "Answer");
static assert(getUDAs!(a, Attr)[0].value == 42);

@(Attr("Answer", 42), "string", 9999) int b;
static assert(getUDAs!(b, Attr).length == 1);
static assert(getUDAs!(b, Attr)[0].name == "Answer");
static assert(getUDAs!(b, Attr)[0].value == 42);

@Attr("Answer", 42) @Attr("Pi", 3) int c;
static assert(getUDAs!(c, Attr).length == 2);
static assert(getUDAs!(c, Attr)[0].name == "Answer");
static assert(getUDAs!(c, Attr)[0].value == 42);
static assert(getUDAs!(c, Attr)[1].name == "Pi");
static assert(getUDAs!(c, Attr)[1].value == 3);

static assert(getUDAs!(c, Attr("Answer", 42)).length == 1);
static assert(getUDAs!(c, Attr("Answer", 42))[0].name == "Answer");
static assert(getUDAs!(c, Attr("Answer", 42))[0].value == 42);

static assert(getUDAs!(c, Attr("Answer", 99)).length == 0);

struct AttrT(T)
{
    string name;
    T value;
}

@AttrT!uint("Answer", 42) @AttrT!int("Pi", 3) @AttrT int d;
static assert(getUDAs!(d, AttrT).length == 2);
static assert(getUDAs!(d, AttrT)[0].name == "Answer");
static assert(getUDAs!(d, AttrT)[0].value == 42);
static assert(getUDAs!(d, AttrT)[1].name == "Pi");
static assert(getUDAs!(d, AttrT)[1].value == 3);

static assert(getUDAs!(d, AttrT!uint).length == 1);
static assert(getUDAs!(d, AttrT!uint)[0].name == "Answer");
static assert(getUDAs!(d, AttrT!uint)[0].value == 42);

static assert(getUDAs!(d, AttrT!int).length == 1);
static assert(getUDAs!(d, AttrT!int)[0].name == "Pi");
static assert(getUDAs!(d, AttrT!int)[0].value == 3);

struct SimpleAttr {}

@SimpleAttr int e;
static assert(getUDAs!(e, SimpleAttr).length == 1);
static assert(is(getUDAs!(e, SimpleAttr)[0] == SimpleAttr));

@SimpleAttr() int f;
static assert(getUDAs!(f, SimpleAttr).length == 1);
static assert(is(typeof(getUDAs!(f, SimpleAttr)[0]) == SimpleAttr));

struct FuncAttr(alias f) { alias func = f; }
static int add42(int v) { return v + 42; }
static string concat(string l, string r) { return l ~ r; }

@FuncAttr!add42 int g;
static assert(getUDAs!(g, FuncAttr).length == 1);
static assert(getUDAs!(g, FuncAttr)[0].func(5) == 47);

static assert(getUDAs!(g, FuncAttr!add42).length == 1);
static assert(getUDAs!(g, FuncAttr!add42)[0].func(5) == 47);

static assert(getUDAs!(g, FuncAttr!add42()).length == 0);

static assert(getUDAs!(g, FuncAttr!concat).length == 0);
static assert(getUDAs!(g, FuncAttr!concat()).length == 0);

@FuncAttr!add42() int h;
static assert(getUDAs!(h, FuncAttr).length == 1);
static assert(getUDAs!(h, FuncAttr)[0].func(5) == 47);

static assert(getUDAs!(h, FuncAttr!add42).length == 1);
static assert(getUDAs!(h, FuncAttr!add42)[0].func(5) == 47);

static assert(getUDAs!(h, FuncAttr!add42()).length == 1);
static assert(getUDAs!(h, FuncAttr!add42())[0].func(5) == 47);

static assert(getUDAs!(h, FuncAttr!concat).length == 0);
static assert(getUDAs!(h, FuncAttr!concat()).length == 0);

@("alpha") @(42) int i;
static assert(getUDAs!(i, "alpha").length == 1);
static assert(getUDAs!(i, "alpha")[0] == "alpha");

static assert(getUDAs!(i, 42).length == 1);
static assert(getUDAs!(i, 42)[0] == 42);

static assert(getUDAs!(i, 'c').length == 0);

template getSymbolsByUDA(alias symbol, alias attribute)

Parameters:

symbol	The aggregate type or module to search
attribute	The user-defined attribute to search for

Returns:

All symbols within symbol that have the given UDA attribute.

Note This is not recursive; it will not search for symbols within symbols such as nested structs or unions.

Examples:

enum Attr;
struct A
{
    @Attr int a;
    int b;
}

static assert(getSymbolsByUDA!(A, Attr).length == 1);
static assert(hasUDA!(getSymbolsByUDA!(A, Attr)[0], Attr));

Examples:

enum Attr;

static struct A
{
    @Attr int a;
    int b;
    @Attr void doStuff() {}
    void doOtherStuff() {}
    static struct Inner
    {
        // Not found by getSymbolsByUDA
        @Attr int c;
    }
}

// Finds both variables and functions with the attribute, but
// doesn't include the variables and functions without it.
static assert(getSymbolsByUDA!(A, Attr).length == 2);
// Can access attributes on the symbols returned by getSymbolsByUDA.
static assert(hasUDA!(getSymbolsByUDA!(A, Attr)[0], Attr));
static assert(hasUDA!(getSymbolsByUDA!(A, Attr)[1], Attr));

Examples:

Finds multiple attributes

static struct UDA { string name; }

static struct B
{
    @UDA("X")
    int x;
    @UDA("Y")
    int y;
    @(100)
    int z;
}

// Finds both UDA attributes.
static assert(getSymbolsByUDA!(B, UDA).length == 2);
// Finds one `100` attribute.
static assert(getSymbolsByUDA!(B, 100).length == 1);
// Can get the value of the UDA from the return value
static assert(getUDAs!(getSymbolsByUDA!(B, UDA)[0], UDA)[0].name == "X");

Examples:

Checks for UDAs on the aggregate symbol itself

static struct UDA { string name; }

@UDA("A")
static struct C
{
    @UDA("B")
    int d;
}

static assert(getSymbolsByUDA!(C, UDA).length == 2);
static assert(getSymbolsByUDA!(C, UDA)[0].stringof == "C");
static assert(getSymbolsByUDA!(C, UDA)[1].stringof == "d");

Examples:

Finds nothing if there is no member with specific UDA

static struct UDA { string name; }

static struct D
{
    int x;
}

static assert(getSymbolsByUDA!(D, UDA).length == 0);

enum bool allSameType(Ts...);

Returns:

true iff all types Ts are the same.

Examples:

static assert(allSameType!());
static assert(allSameType!(int));
static assert(allSameType!(int, int));
static assert(allSameType!(int, int, int));
static assert(allSameType!(float, float, float));
static assert(!allSameType!(int, double));
static assert(!allSameType!(int, float, double));
static assert(!allSameType!(int, float, double, real));
static assert(!allSameType!(short, int, float, double, real));

enum auto ifTestable(T, alias pred = (a) => a);

Returns:

true iff the type T can be tested in an if-expression, that is if if (pred(T.init)) {} is compilable.

Examples:

class C;
struct S1;
struct S2
{
    T opCast(T)() const;
}

static assert( ifTestable!bool);
static assert( ifTestable!int);
static assert( ifTestable!(S1*));
static assert( ifTestable!(typeof(null)));
static assert( ifTestable!(int[]));
static assert( ifTestable!(int[string]));
static assert( ifTestable!S2);
static assert( ifTestable!C);
static assert(!ifTestable!S1);

enum auto isType(alias X);

Detect whether X is a type. Analogous to is(X). This is useful when used in conjunction with other templates, e.g. allSatisfy!(isType, X).

Returns:

true if X is a type, false otherwise

Examples:

struct S {
    template Test() {}
}
class C {}
interface I {}
union U {}
static assert(isType!int);
static assert(isType!string);
static assert(isType!(int[int]));
static assert(isType!S);
static assert(isType!C);
static assert(isType!I);
static assert(isType!U);

int n;
void func(){}
static assert(!isType!n);
static assert(!isType!func);
static assert(!isType!(S.Test));
static assert(!isType!(S.Test!()));

template isFunction(alias X)

Detect whether symbol or type X is a function. This is different that finding if a symbol is callable or satisfying is(X == function), it finds specifically if the symbol represents a normal function declaration, i.e. not a delegate or a function pointer.

Returns:

true if X is a function, false otherwise

See Also:

Use isFunctionPointer or isDelegate for detecting those types respectively.

Examples:

static void func(){}
static assert(isFunction!func);

struct S
{
    void func(){}
}
static assert(isFunction!(S.func));

template isFinal(alias X)

Detect whether X is a final method or class.

Returns:

true if X is final, false otherwise

Examples:

class C
{
    void nf() {}
    static void sf() {}
    final void ff() {}
}
final class FC { }

static assert(!isFinal!(C));
static assert( isFinal!(FC));

static assert(!isFinal!(C.nf));
static assert(!isFinal!(C.sf));
static assert( isFinal!(C.ff));

enum auto isCopyable(S);

Determines whether the type S can be copied. If a type cannot be copied, then code such as MyStruct x; auto y = x; will fail to compile. Copying for structs can be disabled by using @disable this(this).

cond	A bool which determines which function is run
A `a`	The first function
B `b`	The second function

T	Type containing symbol member.
member	Name of symbol to test that resides in T.

Library Reference

std.traits