Compile-time reflection D

__traits( compiles, a + b ); is( typeof( a + b ) ); 

 template isNumArray(T) { enum isNumArray = __traits(compiles, { auto a = T.init[0]; // opIndex  int  static if( !__traits(isArithmetic,a) ) //    ,    { static assert( __traits( compiles, a=a+a ) ); //  static assert( __traits( compiles, a=aa ) ); //  static assert( __traits( compiles, a=a*.0f ) ); //   float } auto b = T.init.length; //  length static assert( is( typeof(b) : size_t ) ); }); } auto mean(T)( T arr ) @property if( isNumArray!T ) in { assert( arr.length > 0 ); } body { //     arr[index]  arr.length //   ,  arr[index]     auto ret = arr[0] - arr[0]; //       (0) foreach( i; 0 .. arr.length ) ret = ret + arr[i]; //      += return ret * ( 1.0f / arr.length ); } 

 import std.string : format; struct Vec2 { float x=0, y=0; //      auto opBinary(string op)( auto ref const Vec2 rhs ) const if( op == "+" || op == "-" ) { mixin( format( "return Vec2( x %1$s rhs.x, y %1$s rhs.y );", op ) ); } //    auto opBinary(string op)( float rhs ) const if( op == "*" ) { return Vec2( x * rhs, y * rhs ); } } struct Triangle { Vec2 p1, p2, p3; //    var[index] auto opIndex(size_t v) { switch(v) { case 0: return p1; case 1: return p2; case 2: return p3; default: throw new Exception( "triangle have only three elements" ); } } static pure size_t length() { return 3; } } void main() { auto f = [ 1.0f, 2, 3 ]; assert( f.mean == 2.0f ); //  float  auto v = [ Vec2(1,6), Vec2(2,7), Vec2(3,5) ]; assert( v.mean == Vec2(2,6) ); //    user-defined  auto t = Triangle( Vec2(1,6), Vec2(2,7), Vec2(3,5) ); assert( t.mean == Vec2(2,6) ); //  user-defined  } 

The construction is (...)

 is( T ); //    T 

 is( T == Type ); //    T  Type is( T : Type ); //    T      Type 

 is( T ident ); 

 is( T ident : Type ); is( T ident == Type ); 

 void foo(T)( T value ) { static if( is( TU : long ) ) //   T   long alias Num = U; //   else alias Num = long; //  long } 

 is( T == Specialization ); 

 is( T ident == Specialization ); 

 is( T == TypeTempl, TemplParams... ); is( T : TypeTempl, TemplParams... ); //   alias' is( T ident == TypeTempl, TemplParams... ); is( T ident : TypeTempl, TemplParams... ); 

 struct Foo(size_t N, T) if( N > 0 ) { T[N] data; } struct Bar(size_t N, T) if( N > 0 ) { float[N] arr; T value; } void func(U)( U val ) { static if( is( UE == S!(N,T), alias S, size_t N, T ) ) { pragma(msg, "struct like Foo: ", E ); pragma(msg, "S: ", S.stringof); pragma(msg, "N: ", N); pragma(msg, "T: ", T); } else static if( is( UT : T[X], X ) ) { pragma(msg, "associative array T[X]: ", U ); pragma(msg, "T(value): ", T); pragma(msg, "X(key): ", X); } else static if( is( UT : T[N], size_t N ) ) { pragma(msg, "static array T[N]: ", U ); pragma(msg, "T(value): ", T); pragma(msg, "N(length): ", N); } else pragma(msg, "other: ", U ); pragma(msg,""); } void main() { func( Foo!(10,double).init ); func( Bar!(12,string).init ); func( [ "hello": 23 ] ); func( [ 42: "habr" ] ); func( Foo!(8,short).init.data ); func( 0 ); } 

 struct like Foo: Foo!(10LU, double) S: Foo(ulong N, T) if (N > 0) N: 10LU T: double struct like Foo: Bar!(12LU, string) S: Bar(ulong N, T) if (N > 0) N: 12LU T: string associative array T[X]: int[string] T(value): int X(key): string associative array T[X]: string[int] T(value): string X(key): int static array T[N]: short[8] T(value): short N(length): 8LU other: int 

__Traits construction (keyWord, ...)

• compiles - whether the expression is valid
• isAbstractClass - abstract classes
• isArithmetic - arithmetic types (numbers and enumerations)
• isAssociativeArray - associative arrays
• isFinalClass - final classes (from which you cannot inherit)
• isPOD - Plain Old Data - types that can be initialized by simple byte-wise copying (hidden fields, destructors are prohibited)
• isNested - nested types (context dependent)
  
  Examples

   class A { class B {} } pragma(msg, __traits(isNested,AB)); // true 

  
  

   void f1() { auto f2() { return 12; } pragma(msg,__traits(isNested,f2)); // true } 

  
  

   auto f1() { auto val = 12; struct S { auto f2() { return val; } } //   f1 return S.init; } pragma(msg,__traits(isNested,typeof(f1()))); // true 

• isFloating - floating point numbers (including complex ones)
• isIntegral - integers
• isScalar - scalar types (numbers, enums, pointers), although __vector (int [4]) is also a scalar type
• isStaticArray - static arrays
• isUnsigned - unsigned integer numbers
• isVirtualMethod - virtual method (something that can be overloaded)
• isVirtualFunction - virtual functions (those that are in the table of virtual functions)
• isAbstractFunction - abstract function
• isFinalFunction - final function
• isStaticFunction - static function
• isOverrideFunction - overloaded function
• isRef - link argument
• isOut - output argument link
• isLazy is a lazy argument (calculated on demand)
• isSame - expressions are the same
• hasMember - if the class / structure has such a field / method, the first argument takes a type (or an object of the type), the second one takes the string with the field / method name
  
  Example

   struct Foo { float value; } pragma(msg, __traits(hasMember, Foo, "value")); // true pragma(msg, __traits(hasMember, Foo, "data")); // false 

 import std.stdio, std.string; string test(alias T)() { string ret; ret ~= is( typeof(T) == delegate ) ? "D " : is( typeof(T) == function ) ? "F " : "? "; ret ~= __traits(isVirtualMethod,T) ? "m|" : "-|"; ret ~= __traits(isVirtualFunction,T) ? "v|" : "-|"; ret ~= __traits(isAbstractFunction,T) ? "a|" : "-|"; ret ~= __traits(isFinalFunction,T) ? "f|" : "-|"; ret ~= __traits(isStaticFunction,T) ? "s|" : "-|"; ret ~= __traits(isOverrideFunction,T) ? "o|" : "-|"; return ret; } class A { static void stat() {} void simple1() {} void simple2() {} private void simple3() {} abstract void abstr() {} final void fnlNOver() {} } class B : A { override void simple1() {} final override void simple2() {} override void abstr() {} } class C : B { final override void abstr() {} } interface I { void abstr(); final void fnl() {} } struct S { void func(){} } void globalFunc() {} void main() { A a; B b; C c; I i; S s; writeln( " id T m|v|a|f|s|o|" ); writeln( "--------------------------" ); writeln( " lambda: ", test!(x=>x) ); writeln( " function: ", test!((){ return 3; }) ); writeln( " delegate: ", test!((){ return b; }) ); writeln( " s.func: ", test!(s.func) ); writeln( " global: ", test!(globalFunc) ); writeln( " a.stat: ", test!(a.stat) ); writeln( " a.simple1: ", test!(a.simple1) ); writeln( " a.simple2: ", test!(a.simple2) ); writeln( " a.simple3: ", test!(a.simple3) ); writeln( " a.abstr: ", test!(a.abstr) ); writeln( "a.fnlNOver: ", test!(a.fnlNOver) ); writeln( " b.simple1: ", test!(b.simple1) ); writeln( " b.simple2: ", test!(b.simple2) ); writeln( " b.abstr: ", test!(b.abstr) ); writeln( " c.abstr: ", test!(c.abstr) ); writeln( " i.abstr: ", test!(i.abstr) ); writeln( " i.fnl: ", test!(i.fnl) ); } 

  id T m|v|a|f|s|o| -------------------------- lambda: ? -|-|-|-|-|-| function: ? -|-|-|-|s|-| delegate: D -|-|-|-|-|-| s.func: F -|-|-|-|-|-| global: F -|-|-|-|s|-| a.stat: F -|-|-|-|s|-| a.simple1: F m|v|-|-|-|-| a.simple2: F m|v|-|-|-|-| a.simple3: F -|-|-|-|-|-| a.abstr: F m|v|a|-|-|-| a.fnlNOver: F -|v|-|f|-|-| b.simple1: F m|v|-|-|-|o| b.simple2: F m|v|-|f|-|o| b.abstr: F m|v|-|-|-|o| c.abstr: F m|v|-|f|-|o| i.abstr: F m|v|a|-|-|-| i.fnl: F -|-|a|f|-|-| 

• identifier - takes one argument, returns a string (similar to .stringof)
• getAliasThis - takes a type or an object of a type, if the type has alias this, returns them as a tuple of strings, otherwise the empty tuple (as I recall, only one alias this is supported for the type)
• getAttributes - takes an identifier, returns a tuple of user-defined attributes (UDA - user defined attributes)
  
  Example

   enum Foo; class Bar { @​(42) @​Foo void func() pure @​nogc @​property {} } pragma(msg, __traits(getAttributes, Bar.func)); // tuple(42, (Foo)), @​nogc  @​property      @​Foo float value; pragma(msg, __traits(getAttributes, value)); // tuple((Foo)),      

• getFunctionAttributes takes a function, a functional literal, a pointer to a function, returns a tuple of attributes in the form of strings (the UDA does not enter here). Pure, nothrow, @ nogc, @ property, @ system, @ trusted, @ safe and ref (if the function returns a reference) are supported, for classes / structures there is also const, immutable, inout and shared. The order depends on the implementation and cannot be relied upon.
  
  Example

   enum Foo; class Bar { @​(42) @​Foo void func() pure @​nogc @​property {} } pragma(msg, __traits(getFunctionAttributes, Bar.func)); // tuple("pure", "@​nogc", "@​property", "@​system") 

• getMember - takes the same arguments as hasMember, equivalent to writing through a dot
  
  Example

   class Bar { float value; } Bar bar; __traits(getMember, bar, "value") = 10; //    bar.value = 10; 

• getOverloads - takes a class / structure / module and a string that matches the function name inside the class / structure / module, returns a tuple of all overloads of this function
  
  Example

   import std.stdio; class A { void foo( float ) {} void foo( string ) {} int foo( int ) { return 12; } } void main() { foreach( f; __traits(getOverloads, A, "foo") ) writeln( typeof(f).stringof ); } 

  Result
  

   void(float _param_0) void(string _param_0) int(int _param_0) 

• getPointerBitmap - takes a type, returns an array size_t. The first number is the number of bytes occupied by an object of this type, the second describes the location of pointers managed by the garbage collector inside an object of this type
  
  Example

   class A { //     ,  1 ,  GC:  // monitor,  ,  1,  GC:  float val1; //  1, GC:  A val2; //  1, GC:  void* val3; //  1, GC:  void[] val4; //  2 { GC: , GC: } void function() val5; //  1, GC:  void delegate() val6; //  2 { GC: , GC: } } enum bm = 0b101011000; // ||||||||+-      // |||||||+--   monitor // ||||||+--- float val1 // |||||+---- A val2 // ||||+----- void* val3 // |||+------ void[] val4  // ||+------- void[] val4  // |+-------- void function() val5  // +--------- void delegate() val6  // 0---------- void delegate() val6  static assert( __traits(getPointerBitmap,A) == [10*size_t.sizeof, bm] ); struct B { float x, y, z; } static assert( __traits(getPointerBitmap,B) == [3*float.sizeof, 0] ); //   B  ,    

• getProtection - accepts a character, returns a string, possible options: “public”, “private”, “protected”, “export” and “package”
• getVirtualMethods - takes a class and a string with the name of a function, works almost like getOverloads, returns a tuple of functions
• getVirtualFunctions is the same as getVirtualMethods, except that this includes final functions that do not overload anything
• getUnitTests - accepts a class / structure / module, returns a unit-class tuple as static functions, the UDA is saved
• parent - returns the parent character for the passed
  
  Example

   import std.stdio; struct B { float value; void func() {} } alias F = B.func; void main() { writeln( __traits(parent,writeln).stringof ); // module stdio writeln( typeid( typeof( __traits(parent,F).value ) ) ); // float } 

• classInstanceSize - takes a class, returns the number of bytes occupied by the class instance
• getVirtualIndex - takes a function (class method), returns an index (ptrdiff_t) in the table of virtual functions of the class. If the function is final and does not override anything, returns -1
• allMembers - takes a type and returns a tuple of strings with the names of all fields and methods without repetitions and built-in properties (sizeof, for example), for classes it also includes fields and methods of base classes
• derivedMembers - takes a type and returns a tuple of strings with the names of all fields and methods without repetitions, without embedded properties and without fields and methods of base classes (for classes)

Standardization and Restriction of Signatures

 void func(T)( T val ) { ... } 

 import std.stdio; void func(T:long)( T val ) { writeln( "number" ); } void func(T: U[E], U, E)( T val ) if( is( E == string ) ) { writeln( "AA with string key" ); } void func(T: U[E], U, E)( T val ) if( is( E : long ) ) { writeln( "AA with num key" ); } void main() { func( 120 ); // number func( ["hello": 12] ); // AA with string key func( [10: 12] ); // AA with num key } 

Standard library

• std.traits - includes many checks and wrappers
• std.typetuple - templates for working with type tuples

Total