Metaprogramming work around

["Erèbe"]

On Tuesday, 17 April 2012 at 10:29:56 UTC, Kenji Hara wrote:
> On Tuesday, 17 April 2012 at 08:28:45 UTC, Erèbe wrote:
>> Hi,
>>
>> I'm working on some metaprogramming code which implement a 
>> Factory and generate an enum from a list of string.
>>
>> So here my questions :
>>
>> 1) The documentation say mixin templates could take as 
>> TemplateParameterList
>> a "TemplateParameter , TemplateParameterList" but all my tried 
>> to instaciate this template failed lamentably.
>>
>> mixin template Foo(T, R...)
>> {
>>
>>   anotherTemplate!(T);
>>   Foo!(R);
>>
>> }
>>
>> mixin Foo!( string, string, string);
>>
>> Is something wrong with variadic template and mixin, do i miss 
>> something ?
>>
>>
>> 2) Below some code I writed and I wanted to know if you have 
>> some advice to improve it (Right maner to do it, TypeChecking, 
>> Safety, ...) <- variaidc arguments
>>
>>
>> The code is working is purpose is to create an enum of 
>> commands and to create a factory which returns me the command 
>> associated to a string.
>>
>> Thanks !
>>
>> ===========================Code============================================
>> import std.stdio;
>> import std.traits;
>> import std.conv;
>>
>>
>> //Use to create the enums of every commands
>> mixin template enumGenerator( T... )
>> {
>>
>>    template generate( T... )
>>    {
>>        enum string value = T[0] ~ ", " ~ generate!( T[2..$] 
>> ).value;
>>    }
>>
>>    template generate() { enum string value = "UNKNOW"; }
>>
>>
>>    //Here the creation of the enum
>>    mixin("enum Command { " ~ generate!(T).value ~ "};");
>>
>> }
>>
>> //Generate a function which return a command in regard of a 
>> string
>> mixin template factoryGenerator( T... )
>> {
>>    template generate( T... )
>>    {
>>        enum string value = "if( cmd == \"" ~ T[1] ~ "\")"
>>                                ~ "return Command." ~ T[0] ~ ";"
>>                            ~ "else "
>>                                ~ generate!(T[2..$]).value;
>>    }
>>
>>    template generate() { enum string value = "return 
>> Command.UNKNOW;"; }
>>
>>    //The function in question
>>    auto CommandFactory( string cmd )
>>    {
>>            mixin( generate!(T).value );
>>    }
>>
>> }
>>
>>
>> mixin template IrcCommands( T... )
>> {
>>
>>   mixin enumGenerator!( T );
>>   mixin factoryGenerator!( T );
>>
>> }
>>
>>
>> void main()
>> {
>>
>>                       /*Command*/     /*String associated*/
>>   mixin IrcCommands!( "Connected",    "001",
>>                       "NicknameUsed", "433",
>>                       "Message",      "PRIVMSG",
>>                       "UserLeaved",   "PART",
>>                       "UserJoined",   "JOIN",
>>                       "UserQuit",     "QUIT"
>
>                          "UserQuit",     "QUIT",   // lack of 
> comma
>
>>                       "Ping",         "PING" );
>>
>>   writefln( to!string(CommandFactory("001")) );
>>
>>
>> }
>
> You can debug templates with adding static assertions in some 
> where, like:
>
> mixin template enumGenerator( T... )
> {
>     template generate( T... )
>     {
>         static assert(T.length%2==0 && is(typeof(T[0]) : 
> string));  // check
>         enum string value = T[0] ~ ", " ~ generate!( T[2..$] 
> ).value;
>     }
>     //[snip]
> }
>
> mixin template factoryGenerator( T... )
> {
>     template generate( T... )
>     {
>         static assert(T.length%2==0 && is(typeof(T[1]) : 
> string));  // check
>         enum string value = "if( cmd == \"" ~ T[1] ~ "\")"
>                                 ~ "return Command." ~ T[0] ~ ";"
>                             ~ "else "
>                                 ~ generate!(T[2..$]).value;
>     }
>     //[snip]
> }
>
> Bye.
>
> Kenji Hara

Thanks for the comma !

The issue with static assert (in my case) is that the compiler 
blow you a full page of "template's instatiation error" before 
the message of your assert. Ok not even a page of the size of c++ 
template error, but that lead to your message be less noticeable.
While browsering the standard librairy I found this :

static if ( expression )
      //put your code here
else
   assert(false, "your message");

With this, the compiler print just one line, "your message". That 
pretty neat and readable enough for me :)

> Stick in the magic pragma(msg, value); in here you won't regret 
> it ;)
> Another important thing to note here is that you should really 
> reconsider using plain if/else if it's a production code not 
> some toy to learn meta programming.
> At very least try to generate switch over strings but I don't 
> think any D compiler optimizes it. (but it should in future)
> Real world options are binary search on string table or even 
> better built-in hash table.

Thanks for pragma, it's awesome !

You guessed right, this code is just for the sake of learning 
some D meta programming. But I will try with an built-in hash 
table.



There is something I still don't understand :

mixin template Foo( T... )
{
//Code here
}

mixin Foo!( "Hello", "Word" ); <---- Good

--------------------------------------------

mixin template Foo( A, T... )
{
//code here
}

mixin Foo!( "Hello", "Word" ); <--- Fail !
mixin Foo!( string, "Word" ); <---- Good
--------------------------------------------

mixin template Foo( alias A, T... )
{
//code here
}

mixin Foo!( "Hello", "world" ); <--- Good
mixin Foo!( string, "world" ); <--- Fail !

---------------------------------------------

Is there someone to enlight me about this behavior ?