[challenge] Limitation in D's metaprogramming

[Robert Jacques]

On Mon, 18 Oct 2010 20:07:16 -0400, Nick Sabalausky <a at a.a> wrote:
> I don't know if others have noticed this before, but I think I've found a
> notable limitation in D's metaprogramming potential: There doesn't  
> appear to
> be a way to have mutable global state at compile-time.
>
> Challange:
>
> Create two..."things"...they can be functions, templates, variables,
> mix-n-match, whatever. One of them increments a counter, and the other  
> can
> be used to retreive the value. But both of these must operate at
> compile-time, and they must both be callable (directly or indirectly,
> doesn't matter) from within the context of any module that imports them.
>
> This is an example, except it operates at run-time, not compile-time:
>
> -----------------------------------
> // a.d
> module a;
> int value=0;
> void inc()
> {
>     value++;
> }
> int get()
> {
>     return value;
> }
>
> void incFromA()
> {
>     inc();
> }
>
> //b.d
> module b;
> import a;
> void incFromB()
> {
>     inc();
> }
>
> //main.d
> import a;
> import b;
> import std.stdio;
> void main()
> {
>     inc();
>     incFromA();
>     incFromB();
>     writeln(get());
> }
> -----------------------------------
>
> The goal of this challenge is to define a global-level manifest constant
> enum that holds a value that has been incremented from multiple modules:
>
> enum GOAL = ????;
>
> It can, of course, then be displayed via:
> pragma(msg, std.conv.to!string(GOAL));
>
> At this point, I'm not concerned about order-of-execution issues  
> resulting
> in unexpected or unpredictable values. As long as a value can be  
> incremented
> at compile-time from multiple modules and used to initialize an enum
> manifest constant, that satisfies this challenge.
>

This isn't exactly what you're looking for, but you can abuse conditional  
compilation + D's symbol table to create a scoped counter:

string nthLabel(int n) {
     return "__Global_"~ to!string(n);
}
string incGlobal() {
     return `mixin("alias int "~nthLabel( getGlobal!(__FILE__, __LINE__)  
)~";");`;
}
template getGlobal(string file = __FILE__, int line = __LINE__, int N = 0)  
{
     static if( !__traits(compiles, mixin(nthLabel(N)) ) )
         enum getGlobal = N;
     else
         enum getGlobal = getGlobal!(file,line, N+1 );
}

enum Foo    = getGlobal!(__FILE__, __LINE__) ;
mixin( incGlobal() );
enum Bar    = getGlobal!(__FILE__, __LINE__);
mixin( incGlobal() );
enum FooBar = getGlobal!(__FILE__, __LINE__);


void main(string[] args) {
     //      0        1        2
     writeln(Foo,'\t',Bar,'\t',FooBar);
     return;
}