Making enum join variadic

["Nordlöw" via Digitalmars-d-learn]

> artur

Thx!

Here's my final version that compiles and run:

import std.stdio: writeln;
import traits_ex: isEnum;
import std.typetuple: allSatisfy;

/** Join/Chain/Concatenate/Unite Enums $(D E1), $(D E2), ... into 
$(D E).
     See also: 
http://forum.dlang.org/thread/f9vc6p$1b7k$1@digitalmars.com
*/
template join(ES...) if (allSatisfy!(isEnum, ES)) {
     mixin({
             string r = "enum join { ";
             foreach (E; ES) {
                 import std.range: join;
                 r ~= [__traits(allMembers, E), " "].join(",");
             }
             return r ~ "}";
         }());
}

unittest
{
     enum E1 { a, b, c }
     enum E2 { e, f, g }
     enum E3 { h, i, j}
     alias E1_ = join!(E1);
     alias E12 = join!(E1, E2);
     alias E123 = join!(E1, E2, E3);
     writeln(E123.min, ",", E123.max);
}

Some final questions:

- Is join a good naming for this? Is chain better?
- Is it better to be verbose with joinEnums?
- What other useful enum algorithms are you missing?
- Should this perhaps go into Phobos? If so in what module? 
std.algorithm, range, traits?