Compile time features

[Shammah Chancellor via Digitalmars-d]

On Thursday, 29 October 2015 at 06:02:05 UTC, qsdf wrote:
> On Thursday, 29 October 2015 at 02:43:59 UTC, Shammah 
> Chancellor wrote:
>> ....
>
> I agree with you on an aspect: writing code with __traits() 
> often leads to a  cascade of "unfriendly", "cryptic", 
> "undigest", static if and loops.
>
> However your examples are discutables:
>
> 1/ The symbol is not always a type, so to test it there is 
> `if(is()){}`:
>
> ---
> import std.stdio;
>
> enum hack(A...) = A;
>
> int main() {
> 	foreach(member; __traits(allMembers, std.stdio)) {
> 		pragma(msg, member);
>         static if (is(member))
> 		    alias sym = hack!(__traits(getMember, std.stdio, 
> member))[0];
> 	}
> }
> ---

The point is that you cannot use is() without first using 
getMember, but using __traits(getMember) before 
__traits(compiles) generates an error.  In your example you're 
trying to use `is` on a string, which does not work.

>
> 2/ with only one way to define the alias it works, whatever is 
> the function type (property or not)
>
> ---
> import std.traits, std.stdio, std.typetuple;
>
> private template MemberType(C, string memberName)
> {
>     alias member = TypeTuple!(__traits (getMember, C, 
> memberName))[0];
>     static if (isSomeFunction!(typeof(&member)))
>         alias MemberType = typeof(&member);
>     else static assert(0, "not handled here !");
> }
>
> struct Hop
> {
>     void foo(uint a){}
>     @property uint bar(){return 0;}
>     uint baz(){return 0;}
>     @property void bla(uint h){}
> }
>
> void main()
> {
>     MemberType!(Hop, "foo").stringof.writeln;
>     MemberType!(Hop, "bar").stringof.writeln;
>     MemberType!(Hop, "baz").stringof.writeln;
>     MemberType!(Hop, "bla").stringof.writeln;
> }
> ---

And you snipped out important sections of code for dealing with 
fields.  The following code now will not compile:

getType.d(7): Error: need 'this' for address of bob
getType.d(27): Error: template instance getType.MemberType!(Hop, 
"bob") error instantiating


```
struct Hop
{
     int bob;
}

void main()
{
     MemberType!(Hop, "bob").stringof.writeln;
}
```



>
> 3/ Your example doesn't compile

Sorry, try this:

```
import std.stdio : writeln;
import std.typetuple;
// This won't work:
/+
private template stuff(Args...) {
	/+ static +/ foreach(Arg; Args) {
		...
	}
}
+/
// Must do this instead:
private template expand(Args...)
{
	static if (Args.length > 0)
	{
		static if (Args.length > 1)
		{
			enum expand = AliasSeq!(repeat!(Args[0], Args.length), 
expand!(Args[1..$]));
		}
		else static if (Args.length == 1)
		{
			enum expand = AliasSeq!(repeat!(Args[0], Args.length));
		}
	}
}
private template repeat(alias T, int times) {
	static if ( times > 1 ) {
		enum repeat = AliasSeq!(T, repeat!(T, times-1));
	} else static if (times == 1) {
		enum repeat = AliasSeq!(T);
	}
}
enum things = expand!("A","B","C");

void main() {
	pragma(msg, things);
	writeln("Hello World");
}
```