D Programming Language
Improve this page 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 local clone. Page wiki View or edit the community-maintained wiki page associated with this page.

# std.traits

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

Category | Templates
--- | ---
Symbol Name traits | fullyQualifiedName moduleName packageName
Function traits | arity functionAttributes functionLinkage FunctionTypeOf isSafe isUnsafe ParameterDefaultValueTuple ParameterIdentifierTuple ParameterStorageClassTuple ParameterTypeTuple ReturnType SetFunctionAttributes variadicFunctionStyle
Aggregate Type traits | BaseClassesTuple BaseTypeTuple classInstanceAlignment EnumMembers FieldNameTuple FieldTypeTuple hasAliasing hasElaborateAssign hasElaborateCopyConstructor hasElaborateDestructor hasIndirections hasMember hasNested hasUnsharedAliasing InterfacesTuple isNested MemberFunctionsTuple RepresentationTypeTuple TemplateArgsOf TemplateOf TransitiveBaseTypeTuple
Type Conversion | CommonType ImplicitConversionTargets isAssignable isCovariantWith isImplicitlyConvertible
Categories of types | isAggregateType isArray isAssociativeArray isBasicType isBoolean isBuiltinType isDynamicArray isFloatingPoint isIntegral isNarrowString isNumeric isPointer isScalarType isSigned isSomeChar isSomeString isStaticArray isUnsigned
Type behaviours | isAbstractClass isAbstractFunction isCallable isDelegate isExpressionTuple isFinalClass isFinalFunction isFunctionPointer isInstanceOf isIterable isMutable isSomeFunction isTypeTuple
General Types | ForeachType KeyType Largest mostNegative OriginalType PointerTarget Signed Unqual Unsigned ValueType
Misc | mangledName Select select

License:
Boost License 1.0.
Authors:
Walter Bright, Tomasz Stachowiak (isExpressionTuple), Andrei Alexandrescu, Shin Fujishiro, Robert Clipsham, David Nadlinger, Kenji Hara, Shoichi Kato

Source: std/traits.d

template packageName(alias T)
  Get the full package name for the given symbol.
  Examples:

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

template moduleName(alias T)
  Get the module name (including package) for the given symbol.
  Examples:

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

template fullyQualifiedName(T...) if (T.length == 1)
  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(func...) if (func.length == 1 && 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).
  Examples:

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

template ParameterTypeTuple(func...) if (func.length == 1 && 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(ParameterTypeTuple!foo);      // declares void bar(int, long);
      void abc(ParameterTypeTuple!foo[1]);   // declares void abc(long);

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

enum ParameterStorageClass: uint;
template ParameterStorageClassTuple(func...) if (func.length == 1 && isCallable!func)
  Returns a tuple consisting of the storage classes of the parameters of a function func.
  Examples:

      alias STC = ParameterStorageClass; // shorten the enum name

      void func(ref int ctx, out real result, real param)
      {
      }
      alias pstc = ParameterStorageClassTuple!func;
      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);

  none
  scope_
  out_
  ref_
  lazy_
  return_
    These flags can be bitwise OR-ed together to represent complex storage class.
template ParameterIdentifierTuple(func...) if (func.length == 1 && 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 ParameterDefaultValueTuple(func...) if (func.length == 1 && isCallable!func)
  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.
  Examples:

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

enum FunctionAttribute: uint;
template functionAttributes(func...) if (func.length == 1 && isCallable!func)
  Returns the attributes attached to a function func.
  Examples:

      import std.traits : functionAttributes, FunctionAttribute;

      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_
    These flags can be bitwise OR-ed together to represent a complex attribute.
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);

template 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 areAllSafe(funcs...) if (funcs.length > 0)
  Deprecated. 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. This will be removed in June 2015.
  true all functions are isSafe.

  Example

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

template functionLinkage(func...) if (func.length == 1 && isCallable!func)
  Returns the calling convention of function as a string.
  Examples:

      import std.stdio : writeln, printf;

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

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

enum Variadic: int;
template variadicFunctionStyle(func...) if (func.length == 1 && isCallable!func)
  Determines what kind of variadic parameters function has.
  Examples:

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

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

  no
    Function is not variadic.
  c
    Function is a C-style variadic function.
  d
    Function is a D-style variadic function, which uses
    _argptr and _arguments.
  typesafe
    Function is a typesafe variadic function.
template FunctionTypeOf(func...) if (func.length == 1 && isCallable!func)
  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.

  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 { return 0; }
      }
      static assert(is( typeof(C.value) == int ));
      static assert(is( FunctionTypeOf!(C.value) == function ));

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

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.
  Examples:

      static struct S { }
      static assert(!isNested!S);

      int i;
      struct NestedStruct { void f() { ++i; } }
      static assert(isNested!NestedStruct);

template hasNested(T)
  Determines whether T or any of its representation types have a context pointer.
  Examples:

      static struct S { }

      int i;
      struct NS { void f() { ++i; } }

      static assert(!hasNested!(S[2]));
      static assert(hasNested!(NS[2]));

template FieldTypeTuple(T)
  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.
  Examples:

      struct S { int x; float y; }
      static assert(is(FieldTypeTuple!S == TypeTuple!(int, float)));

template FieldNameTuple(T)
  Get as an expression tuple the names 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 an expression tuple with an empty string.
  Examples:

      struct S { int x; float y; }
      static assert(FieldNameTuple!S == TypeTuple!("x", "y"));
      static assert(FieldNameTuple!int == TypeTuple!"");

template RepresentationTypeTuple(T)
  Get the primitive types of the fields of a struct or class, in topological order.
  Examples:

      struct S1 { int a; float b; }
      struct S2 { char[] a; union { S1 b; S1 * c; } }
      alias R = RepresentationTypeTuple!S2;
      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 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.
  Examples:

      struct S1 { int a; Object b; }
      struct S2 { string a; }
      struct S3 { int a; immutable Object b; }
      struct S4 { float[3] vals; }
      static assert( hasAliasing!S1);
      static assert(!hasAliasing!S2);
      static assert(!hasAliasing!S3);
      static assert(!hasAliasing!S4);

template hasIndirections(T)
  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.
  Examples:

      static assert( hasIndirections!(int[string]));
      static assert( hasIndirections!(void delegate()));
      static assert( hasIndirections!(void delegate() immutable));
      static assert( hasIndirections!(immutable(void delegate())));
      static assert( hasIndirections!(immutable(void delegate() immutable)));

      static assert(!hasIndirections!(void function()));
      static assert( hasIndirections!(void*[1]));
      static assert(!hasIndirections!(byte[1]));

template hasUnsharedAliasing(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 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.
  Examples:

      struct S1 { int a; Object b; }
      struct S2 { string a; }
      struct S3 { int a; immutable Object b; }
      static assert( hasUnsharedAliasing!S1);
      static assert(!hasUnsharedAliasing!S2);
      static assert(!hasUnsharedAliasing!S3);

      struct S4 { int a; shared Object b; }
      struct S5 { char[] a; }
      struct S6 { shared char[] b; }
      struct S7 { float[3] vals; }
      static assert(!hasUnsharedAliasing!S4);
      static assert( hasUnsharedAliasing!S5);
      static assert(!hasUnsharedAliasing!S6);
      static assert(!hasUnsharedAliasing!S7);

template hasElaborateCopyConstructor(S)
  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.
  Examples:

      static assert(!hasElaborateCopyConstructor!int);

      static struct S1 { }
      static struct S2 { this(this) {} }
      static struct S3 { S2 field; }
      static struct S4 { S3[1] field; }
      static struct S5 { S3[] field; }
      static struct S6 { S3[0] field; }
      static struct S7 { @disable this(); S3 field; }
      static assert(!hasElaborateCopyConstructor!S1);
      static assert( hasElaborateCopyConstructor!S2);
      static assert( hasElaborateCopyConstructor!(immutable S2));
      static assert( hasElaborateCopyConstructor!S3);
      static assert( hasElaborateCopyConstructor!(S3[1]));
      static assert(!hasElaborateCopyConstructor!(S3[0]));
      static assert( hasElaborateCopyConstructor!S4);
      static assert(!hasElaborateCopyConstructor!S5);
      static assert(!hasElaborateCopyConstructor!S6);
      static assert( hasElaborateCopyConstructor!S7);

template hasElaborateAssign(S)
  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.
  A type S gets compiler-generated opAssign in case it has an elaborate copy constructor or elaborate destructor.

  Classes and unions never have elaborate assignments.

  Note: Structs with (possibly nested) postblit operator(s) will have a hidden yet elaborate compiler generated assignment operator (unless explicitly disabled).

  Examples:

      static assert(!hasElaborateAssign!int);

      static struct S  { void opAssign(S) {} }
      static assert( hasElaborateAssign!S);
      static assert(!hasElaborateAssign!(const(S)));

      static struct S1 { void opAssign(ref S1) {} }
      static struct S2 { void opAssign(int) {} }
      static struct S3 { S s; }
      static assert( hasElaborateAssign!S1);
      static assert(!hasElaborateAssign!S2);
      static assert( hasElaborateAssign!S3);
      static assert( hasElaborateAssign!(S3[1]));
      static assert(!hasElaborateAssign!(S3[0]));

template hasElaborateDestructor(S)
  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().
  Examples:

      static assert(!hasElaborateDestructor!int);

      static struct S1 { }
      static struct S2 { ~this() {} }
      static struct S3 { S2 field; }
      static struct S4 { S3[1] field; }
      static struct S5 { S3[] field; }
      static struct S6 { S3[0] field; }
      static struct S7 { @disable this(); S3 field; }
      static assert(!hasElaborateDestructor!S1);
      static assert( hasElaborateDestructor!S2);
      static assert( hasElaborateDestructor!(immutable S2));
      static assert( hasElaborateDestructor!S3);
      static assert( hasElaborateDestructor!(S3[1]));
      static assert(!hasElaborateDestructor!(S3[0]));
      static assert( hasElaborateDestructor!S4);
      static assert(!hasElaborateDestructor!S5);
      static assert(!hasElaborateDestructor!S6);
      static assert( hasElaborateDestructor!S7);

template hasMember(T, string name)
  Yields true if and only if T is an aggregate that defines a symbol called name.
  Examples:

      static assert(!hasMember!(int, "blah"));
      struct S1 { int blah; }
      struct S2 { int blah(){ return 0; } }
      class C1 { int blah; }
      class C2 { int blah(){ return 0; } }
      static assert(hasMember!(S1, "blah"));
      static assert(hasMember!(S2, "blah"));
      static assert(hasMember!(C1, "blah"));
      static assert(hasMember!(C2, "blah"));

template EnumMembers(E) if (is(E == enum))
  Retrieves the members of an enumerated type enum E.
  Parameters:

  E | An enumerated type. E may have duplicated values.

  Returns:
  Static tuple composed of the members of the enumerated type E. The members are arranged in the same order as declared in E.

  Note: An enum can have multiple members which have the same value. If you want to use EnumMembers to e.g. generate switch cases at compile-time, you should use the std.typetuple.NoDuplicates template to avoid generating duplicate switch cases.

  Note: Returned values are strictly typed with E. Thus, the following code does not work without the explicit cast:

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

  Cast is not necessary if the type of the variable is inferred. See the example below.
  Examples:
  Creating an array of enumerated values:

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

  A generic function rank(v) in the following example uses this template for finding a member e in an enumerated type E.

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

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.
  Examples:

      interface I1 { }
      interface I2 { }
      interface I12 : I1, I2 { }
      static assert(is(BaseTypeTuple!I12 == TypeTuple!(I1, I2)));

      interface I3 : I1 { }
      interface I123 : I1, I2, I3 { }
      static assert(is(BaseTypeTuple!I123 == TypeTuple!(I1, I2, I3)));

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

      class C1 { }
      class C2 : C1 { }
      class C3 : C2 { }
      static assert(!BaseClassesTuple!Object.length);
      static assert(is(BaseClassesTuple!C1 == TypeTuple!(Object)));
      static assert(is(BaseClassesTuple!C2 == TypeTuple!(C1, Object)));
      static assert(is(BaseClassesTuple!C3 == TypeTuple!(C2, C1, Object)));
      static assert(!BaseClassesTuple!Object.length);

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.
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.
  Examples:

      interface J1 {}
      interface J2 {}
      class B1 {}
      class B2 : B1, J1, J2 {}
      class B3 : B2, J1 {}
      alias TL = TransitiveBaseTypeTuple!B3;
      assert(TL.length == 5);
      assert(is (TL[0] == B2));
      assert(is (TL[1] == B1));
      assert(is (TL[2] == Object));
      assert(is (TL[3] == J1));
      assert(is (TL[4] == J2));

      assert(TransitiveBaseTypeTuple!Object.length == 0);

template MemberFunctionsTuple(C, string name) if (is(C == class) || is(C == interface))
  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.
  Examples:

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

template TemplateOf(alias T : Base!Args, alias Base, Args...)
  Returns an alias to the template that T is an instance of.
template TemplateArgsOf(alias T : Base!Args, alias Base, Args...)
template TemplateArgsOf(T : Base!Args, alias Base, Args...)
  Returns a TypeTuple of the template arguments used to instantiate T.
  Examples:

      struct Foo(T, U) {}
      static assert(is(TemplateArgsOf!(Foo!(int, real)) == TypeTuple!(int, real)));

template classInstanceAlignment(T) if (is(T == class))
  Returns class instance alignment.
  Examples:

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

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.
  Examples:

      alias X = CommonType!(int, long, short);
      assert(is(X == long));
      alias Y = CommonType!(int, char[], short);
      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 isImplicitlyConvertible(From, To)
  Is From implicitly convertible to To?
template 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));

template isCovariantWith(F, G) if (is(F == function) && is(G == function))
  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.

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

  Examples:

      // 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

template isBoolean(T)
  Detect whether T is a built-in boolean type.
  Examples:

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

template isIntegral(T)
  Detect whether T is a built-in integral type. Types bool, char, wchar, and dchar are not considered integral.
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 (integral or floating point).
template isScalarType(T)
  Detect whether T is a scalar type (a built-in numeric, character or boolean type).
  Examples:

      static assert(!isScalarType!void);
      static assert( isScalarType!(immutable(int)));
      static assert( isScalarType!(shared(float)));
      static assert( isScalarType!(shared(const bool)));
      static assert( isScalarType!(const(dchar)));

template isBasicType(T)
  Detect whether T is a basic type (scalar type or void).
  Examples:

      static assert(isBasicType!void);
      static assert(isBasicType!(immutable(int)));
      static assert(isBasicType!(shared(float)));
      static assert(isBasicType!(shared(const bool)));
      static assert(isBasicType!(const(dchar)));

template isUnsigned(T)
  Detect whether T is a built-in unsigned numeric type.
template isSigned(T)
  Detect whether T is a built-in signed numeric type.
template isSomeChar(T)
  Detect whether T is one of the built-in character types.
  Examples:

      static assert(!isSomeChar!int);
      static assert(!isSomeChar!byte);
      static assert(!isSomeChar!string);
      static assert(!isSomeChar!wstring);
      static assert(!isSomeChar!dstring);
      static assert(!isSomeChar!(char[4]));

template isSomeString(T)
  Detect whether T is one of the built-in string types.
  The built-in string types are Char[], where Char is any of char, wchar or dchar, with or without qualifiers.

  Static arrays of characters (like char[80]) are not considered built-in string types.
  Examples:

      static assert(!isSomeString!int);
      static assert(!isSomeString!(int[]));
      static assert(!isSomeString!(byte[]));
      static assert(!isSomeString!(typeof(null)));
      static assert(!isSomeString!(char[4]));

      enum ES : string { a = "aaa", b = "bbb" }
      static assert( isSomeString!ES);

template isStaticArray(T)
  Detect whether type T is a static array.
  Examples:

      static assert(!isStaticArray!(const(int)[]));
      static assert(!isStaticArray!(immutable(int)[]));
      static assert(!isStaticArray!(const(int)[4][]));
      static assert(!isStaticArray!(int[]));
      static assert(!isStaticArray!(int[char]));
      static assert(!isStaticArray!(int[1][]));
      static assert(!isStaticArray!(int[int]));
      static assert(!isStaticArray!int);

template isDynamicArray(T)
  Detect whether type T is a dynamic array.
template isArray(T)
  Detect whether type T is an array (static or dynamic; for associative arrays see isAssociativeArray).
template isAssociativeArray(T)
  Detect whether T is an associative array type
template isBuiltinType(T)
  Detect whether type T is a builtin type.
template isSIMDVector(T)
  Detect whether type T is a SIMD vector type.
template isPointer(T)
  Detect whether type T is a pointer.
template PointerTarget(T : T*)
  Returns the target type of a pointer.
deprecated alias pointerTarget = PointerTarget(T : T*);
  Deprecated. Please use PointerTarget instead. This will be removed in June 2015.
template isAggregateType(T)
  Detect whether type T is an aggregate type.
template isIterable(T)
  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.
  Examples:

      struct OpApply
      {
          int opApply(int delegate(ref uint) dg) { assert(0); }
      }

      struct Range
      {
          @property uint front() { assert(0); }
          void popFront() { assert(0); }
          enum bool empty = false;
      }

      static assert( isIterable!(uint[]));
      static assert( isIterable!OpApply);
      static assert( isIterable!(uint[string]));
      static assert( isIterable!Range);

      static assert(!isIterable!uint);

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

      static assert( isMutable!int);
      static assert( isMutable!string);
      static assert( isMutable!(shared int));
      static assert( isMutable!(shared const(int)[]));

      static assert(!isMutable!(const int));
      static assert(!isMutable!(inout int));
      static assert(!isMutable!(shared(const int)));
      static assert(!isMutable!(shared(inout int)));
      static assert(!isMutable!(immutable string));

template isInstanceOf(alias S, T)
  Returns true if T is an instance of the template S.
  Examples:

      static struct Foo(T...) { }
      static struct Bar(T...) { }
      static struct Doo(T) { }
      static struct ABC(int x) { }
      static assert(isInstanceOf!(Foo, Foo!int));
      static assert(!isInstanceOf!(Foo, Bar!int));
      static assert(!isInstanceOf!(Foo, int));
      static assert(isInstanceOf!(Doo, Doo!int));
      static assert(isInstanceOf!(ABC, ABC!1));
      static assert(!__traits(compiles, isInstanceOf!(Foo, Foo)));

template isExpressionTuple(T...)
  Check whether the tuple T is an expression tuple. An expression tuple only contains expressions.
  See Also:
  isTypeTuple.
  Examples:

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

template isTypeTuple(T...)
  Check whether the tuple T is a type tuple. A type tuple only contains types.
  See Also:
  isExpressionTuple.
  Examples:

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

template isFunctionPointer(T...) if (T.length == 1)
  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) {}));

template isDelegate(T...) if (T.length == 1)
  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)));

template isSomeFunction(T...) if (T.length == 1)
  Detect whether symbol or type T is a function, a function pointer or a delegate.
template isCallable(T...) if (T.length == 1)
  Detect whether T is a callable object, which can be called with the function call operator (...).
  Examples:

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

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

      static assert(!isCallable!I);

template isAbstractFunction(T...) if (T.length == 1)
  Detect whether T is a an abstract function.
template isFinalFunction(T...) if (T.length == 1)
  Detect whether T is a a final function.
  Examples:

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

template isNestedFunction(alias f)
  Determines whether function f requires a context pointer.
template isAbstractClass(T...) if (T.length == 1)
  Detect whether T is a an abstract class.
  Examples:

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

template isFinalClass(T...) if (T.length == 1)
  Detect whether T is a a final class.
  Examples:

      class C { }
      abstract class AC { }
      final class FC1 : C { }
      final class FC2 { }
      static assert(!isFinalClass!C);
      static assert(!isFinalClass!AC);
      static assert( isFinalClass!FC1);
      static assert( isFinalClass!FC2);

template Unqual(T)
  Removes all qualifiers, if any, from type T.
  Examples:

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

template ForeachType(T)
  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.
  Examples:

      static assert(is(ForeachType!(uint[]) == uint));
      static assert(is(ForeachType!string == immutable(char)));
      static assert(is(ForeachType!(string[string]) == string));
      static assert(is(ForeachType!(inout(int)[]) == inout(int)));

template OriginalType(T)
  Strips off all enums from type T.
  Examples:

      enum E : real { a }
      enum F : E    { a = E.a }
      alias G = const(F);
      static assert(is(OriginalType!E == real));
      static assert(is(OriginalType!F == real));
      static assert(is(OriginalType!G == const real));

template KeyType(V : V[K], K)
  Get the Key type of an Associative Array.
  Examples:

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

template ValueType(V : V[K], K)
  Get the Value type of an Associative Array.
  Examples:

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

template Unsigned(T)
  Returns the corresponding unsigned type for T. T must be a numeric integral type, otherwise a compile-time error occurs.
template Largest(T...) if (T.length >= 1)
  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.
  Examples:

      static assert(is(Largest!(uint, ubyte, ushort, real) == real));
      static assert(is(Largest!(ulong, double) == ulong));
      static assert(is(Largest!(double, ulong) == double));
      static assert(is(Largest!(uint, byte, double, short) == double));

template Signed(T)
  Returns the corresponding signed type for T. T must be a numeric integral type, otherwise a compile-time error occurs.
  Examples:

      alias S1 = Signed!uint;
      static assert(is(S1 == int));
      alias S2 = Signed!(const(uint));
      static assert(is(S2 == const(int)));
      alias S3 = Signed!(immutable(uint));
      static assert(is(S3 == immutable(int)));

template mostNegative(T) if (isNumeric!T || isSomeChar!T || isBoolean!T)
  Returns the most negative value of the numeric type T.
  Examples:

      static assert(mostNegative!float == -float.max);
      static assert(mostNegative!double == -double.max);
      static assert(mostNegative!real == -real.max);
      static assert(mostNegative!bool == false);

  Examples:

      foreach(T; TypeTuple!(bool, byte, short, int, long))
          static assert(mostNegative!T == T.min);

      foreach(T; TypeTuple!(ubyte, ushort, uint, ulong, char, wchar, dchar))
          static assert(mostNegative!T == 0);

template mangledName(sth...) if (sth.length == 1)
  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"

template Select(bool condition, T...) if (T.length == 2)
  Aliases itself to T[0] if the boolean condition is true and to T[1] otherwise.
  Examples:

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

A select(bool cond : true, A, B)(A a, lazy B b);
B select(bool cond : false, A, B)(lazy A a, B b);
  If cond is true, returns a without evaluating b. Otherwise, returns b without evaluating a.

Copyright Digital Mars 2005 - 2009. | Page generated by Ddoc on Tue Mar 24 14:30:33 2015