Traits
Traits are extensions to the language to enable programs, at compile time, to get at information internal to the compiler. This is also known as compile time reflection. It is done as a special, easily extended syntax (similar to Pragmas) so that new capabilities can be added as required.
TraitsExpression:
__traits ( TraitsKeyword , TraitsArguments )
TraitsKeyword:
isAbstractClass
isArithmetic
isAssociativeArray
isFinalClass
isFloating
isIntegral
isScalar
isStaticArray
isUnsigned
isVirtualFunction
isVirtualMethod
isAbstractFunction
isFinalFunction
isStaticFunction
isRef
isOut
isLazy
hasMember
identifier
getMember
getOverloads
getProtection
getVirtualFunctions
getVirtualMethods
parent
classInstanceSize
allMembers
derivedMembers
isSame
compiles
TraitsArguments:
TraitsArgument
TraitsArgument , TraitsArguments
TraitsArgument:
AssignExpression
Type
isArithmetic
If the arguments are all either types that are arithmetic types, or expressions that are typed as arithmetic types, then true is returned. Otherwise, false is returned. If there are no arguments, false is returned.
import std.stdio;
void main() {
int i;
writeln(__traits(isArithmetic, int));
writeln(__traits(isArithmetic, i, i+1, int));
writeln(__traits(isArithmetic));
writeln(__traits(isArithmetic, int*));
}
Prints:
true
true
false
false
isFloating
Works like isArithmetic, except it's for floating point types (including imaginary and complex types).
isIntegral
Works like isArithmetic, except it's for integral types (including character types).
isScalar
Works like isArithmetic, except it's for scalar types.
isUnsigned
Works like isArithmetic, except it's for unsigned types.
isStaticArray
Works like isArithmetic, except it's for static array types.
isAssociativeArray
Works like isArithmetic, except it's for associative array types.
isAbstractClass
If the arguments are all either types that are abstract classes, or expressions that are typed as abstract classes, then true is returned. Otherwise, false is returned. If there are no arguments, false is returned.
import std.stdio;
abstract class C { int foo(); }
void main() {
C c;
writeln(__traits(isAbstractClass, C));
writeln(__traits(isAbstractClass, c, C));
writeln(__traits(isAbstractClass));
writeln(__traits(isAbstractClass, int*));
}
Prints:
true
true
false
false
isFinalClass
Works like isAbstractClass, except it's for final classes.
isVirtualFunction
The same as isVirtualMethod, except that final functions that don't override anything return true.
isVirtualMethod
Takes one argument. If that argument is a virtual function, true is returned, otherwise false. Final functions that don't override anything return false.
import std.stdio;
struct S {
void bar() { }
}
class C {
void bar() { }
}
void main() {
writeln(__traits(isVirtualMethod, C.bar)); // true
writeln(__traits(isVirtualMethod, S.bar)); // false
}
isAbstractFunction
Takes one argument. If that argument is an abstract function, true is returned, otherwise false.
import std.stdio;
struct S {
void bar() { }
}
class C {
void bar() { }
}
class AC {
abstract void foo();
}
void main() {
writeln(__traits(isAbstractFunction, C.bar)); // false
writeln(__traits(isAbstractFunction, S.bar)); // false
writeln(__traits(isAbstractFunction, AC.foo)); // true
}
isFinalFunction
Takes one argument. If that argument is a final function, true is returned, otherwise false.
import std.stdio;
struct S {
void bar() { }
}
class C {
void bar() { }
final void foo();
}
final class FC {
void foo();
}
void main() {
writeln(__traits(isFinalFunction, C.bar)); // false
writeln(__traits(isFinalFunction, S.bar)); // false
writeln(__traits(isFinalFunction, C.foo)); // true
writeln(__traits(isFinalFunction, FC.foo)); // true
}
isStaticFunction
Takes one argument. If that argument is a static function, meaning it has no context pointer, true is returned, otherwise false.
isRef, isOut, isLazy
Takes one argument. If that argument is a declaration, true is returned if it is ref, out, or lazy, otherwise false.
void fooref(ref int x) {
static assert(__traits(isRef, x));
static assert(!__traits(isOut, x));
static assert(!__traits(isLazy, x));
}
void fooout(out int x) {
static assert(!__traits(isRef, x));
static assert(__traits(isOut, x));
static assert(!__traits(isLazy, x));
}
void foolazy(lazy int x) {
static assert(!__traits(isRef, x));
static assert(!__traits(isOut, x));
static assert(__traits(isLazy, x));
}
hasMember
The first argument is a type that has members, or is an expression of a type that has members. The second argument is a string. If the string is a valid property of the type, true is returned, otherwise false.
import std.stdio;
struct S {
int m;
}
void main() {
S s;
writeln(__traits(hasMember, S, "m")); // true
writeln(__traits(hasMember, s, "m")); // true
writeln(__traits(hasMember, S, "y")); // false
writeln(__traits(hasMember, int, "sizeof")); // true
}
identifier
Takes one argument, a symbol. Returns the identifier for that symbol as a string literal.
getMember
Takes two arguments, the second must be a string. The result is an expression formed from the first argument, followed by a ‘.’, followed by the second argument as an identifier.
import std.stdio;
struct S {
int mx;
static int my;
}
void main() {
S s;
__traits(getMember, s, "mx") = 1; // same as s.mx=1;
writeln(__traits(getMember, s, "m" ~ "x")); // 1
__traits(getMember, S, "mx") = 1; // error, no this for S.mx
__traits(getMember, S, "my") = 2; // ok
}
getOverloads
The first argument is a class type or an expression of class type. The second argument is a string that matches the name of one of the functions of that class. The result is a tuple of all the overloads of that function.
import std.stdio;
class D {
this() { }
~this() { }
void foo() { }
int foo(int) { return 2; }
}
void main() {
D d = new D();
foreach (t; __traits(getOverloads, D, "foo"))
writeln(typeid(typeof(t)));
alias typeof(__traits(getOverloads, D, "foo")) b;
foreach (t; b)
writeln(typeid(t));
auto i = __traits(getOverloads, d, "foo")[1](1);
writeln(i);
}
Prints:
void()
int()
void()
int()
2
getProtection
The argument is a symbol. The result is a string giving its protection level: "public", "private", "protected", "export", or "package".
import std.stdio;
class D {
export void foo() { }
public int bar;
}
void main() {
D d = new D();
auto i = __traits(getProtection, d.foo);
writeln(i);
auto j = __traits(getProtection, d.bar);
writeln(j);
}
Prints:
export
public
getVirtualFunctions
The same as getVirtualMethods, except that final functions that do not override anything are included.
getVirtualMethods
The first argument is a class type or an expression of class type. The second argument is a string that matches the name of one of the functions of that class. The result is a tuple of the virtual overloads of that function. It does not include final functions that do not override anything.
import std.stdio;
class D {
this() { }
~this() { }
void foo() { }
int foo(int) { return 2; }
}
void main() {
D d = new D();
foreach (t; __traits(getVirtualMethods, D, "foo"))
writeln(typeid(typeof(t)));
alias typeof(__traits(getVirtualMethods, D, "foo")) b;
foreach (t; b)
writeln(typeid(t));
auto i = __traits(getVirtualMethods, d, "foo")[1](1);
writeln(i);
}
Prints:
void()
int()
void()
int()
2
parent
Takes a single argument which must evaluate to a symbol. The result is the symbol that is the parent of it.
classInstanceSize
Takes a single argument, which must evaluate to either a class type or an expression of class type. The result is of type size_t, and the value is the number of bytes in the runtime instance of the class type. It is based on the static type of a class, not the polymorphic type.
allMembers
Takes a single argument, which must evaluate to either a type or an expression of type. A tuple of string literals is returned, each of which is the name of a member of that type combined with all of the members of the base classes (if the type is a class). No name is repeated. Builtin properties are not included.
import std.stdio;
class D {
this() { }
~this() { }
void foo() { }
int foo(int) { return 0; }
}
void main() {
auto b = [ __traits(allMembers, D) ];
writeln(b);
// ["__ctor", "__dtor", "foo", "toString", "toHash", "opCmp", "opEquals", "Monitor", "factory"]
}
The order in which the strings appear in the result is not defined.
derivedMembers
Takes a single argument, which must evaluate to either a type or an expression of type. A tuple of string literals is returned, each of which is the name of a member of that type. No name is repeated. Base class member names are not included. Builtin properties are not included.
import std.stdio;
class D {
this() { }
~this() { }
void foo() { }
int foo(int) { return 0; }
}
void main() {
auto a = [__traits(derivedMembers, D)];
writeln(a); // ["__ctor", "__dtor", "foo"]
}
The order in which the strings appear in the result is not defined.
isSame
Takes two arguments and returns bool true if they are the same symbol, false if not.
import std.stdio;
struct S { }
int foo();
int bar();
void main() {
writeln(__traits(isSame, foo, foo)); // true
writeln(__traits(isSame, foo, bar)); // false
writeln(__traits(isSame, foo, S)); // false
writeln(__traits(isSame, S, S)); // true
writeln(__traits(isSame, std, S)); // false
writeln(__traits(isSame, std, std)); // true
}
If the two arguments are expressions made up of literals or enums that evaluate to the same value, true is returned.
compiles
Returns a bool true if all of the arguments compile (are semantically correct). The arguments can be symbols, types, or expressions that are syntactically correct. The arguments cannot be statements or declarations.
If there are no arguments, the result is false.
import std.stdio;
struct S {
static int s1;
int s2;
}
int foo();
int bar();
void main() {
writeln(__traits(compiles)); // false
writeln(__traits(compiles, foo)); // true
writeln(__traits(compiles, foo + 1)); // true
writeln(__traits(compiles, &foo + 1)); // false
writeln(__traits(compiles, typeof(1))); // true
writeln(__traits(compiles, S.s1)); // true
writeln(__traits(compiles, S.s3)); // false
writeln(__traits(compiles, 1,2,3,int,long,std)); // true
writeln(__traits(compiles, 3[1])); // false
writeln(__traits(compiles, 1,2,3,int,long,3[1])); // false
}
This is useful for:
- Giving better error messages inside generic code than the sometimes hard to follow compiler ones.
- Doing a finer grained specialization than template partial specialization allows for.