local enum

[Mr.Bingo]

static foreach and enum do not play nice together!

import std.meta, std.stdio;
import std.string : leftJustify, center, rightJustify;
alias functions = staticMap!(ApplyRight!(Instantiate, string),
                              leftJustify, center, rightJustify);

void main()
{
	string result = "|";
	static foreach (f; functions)
	{
		enum y = &f;
		// pragma(msg, y("hello", 17));
		mixin("enum z = &"~f~".stringof;");
		pragma(msg, z);
          	auto x = &f; // not a template, but a function 
instantiation
         	result ~= x("hello", 17);
         	result ~= "|";
	}
	writeln(result); // "hello  ; hello ;  hello;
}

Besides the issue of trying to print out information about f at 
compile time, which is what I was working on here, since the 
above is a cool way to aggregate similar functions at compile 
time, I run in to the notorious issue of using enum's in loops!

The enums are local in nature and are used to store intermediate 
results but the looping tries to redefine them, which gives an 
error.

Instead, how about having a new type or keyword such as __local 
than can create a temporary enum that is only valid inside the 
loop just like a local variable:

void main()
{
	string result = "|";
	static foreach (f; functions)
	{
		__local enum y = &f;
		// pragma(msg, y("hello", 17));
		mixin("__local enum z = &"~f~".stringof;");
		pragma(msg, z);
          	auto x = &f; // not a template, but a function 
instantiation
         	result ~= x("hello", 17);
         	result ~= "|";
	}
	writeln(result); // "hello  ; hello ;  hello;
}

here y and z then are local to the static for each and only exist 
within it's scope. The compiler then will not error out about 
redefinitions.

I know this is a trivial example that does not require __local 
enums but in many cases they are necessary or reduce complexity.


Because I'm nice, I will give a hack that can be used, but this 
hack should only be used by those who think the compiler 
shouldn't automatically do this type of stuff for us:

void main()
{
	static foreach (k, f; [113,22,13])
	{
		mixin("enum y"~to!string(k)~" = f;");		
		mixin("pragma(msg, y"~to!string(k)~");");
	}
}

The idea is simply to create a new enum per loop.  This is not an 
acceptable hack but the compiler could do this internally really 
simple, which is what __local would signify reducing all the 
overhead and the above is then represented as


void main()
{
	static foreach (f; [113,22,13])
	{
		__local enum y = f;		
                 pragma(msg, y);
	}
}

Much nicer and one can imagine how this would simplify a lot of 
code.

Another, probably better idea is to simply allow enums to be 
overwritten at compile time:

void main()
{
         venum y;
	static foreach (f; [113,22,13])
	{
		y = f;		
                 pragma(msg, y);
	}
}