Compile-time optimization

[Yota]

On Tuesday, 23 July 2013 at 20:11:21 UTC, JS wrote:
> Your code doesn't exactly do what I wanted but probably because 
> I wasn't clear... I think it is modifiable and solves the 
> problem I was having(again, assuming your code is correct).
>
> Note though that something like
>
> string x = "asd"
> join(x,...); // x is compile time known and should be joined at 
> compile time. Not sure if D is smart enough to get this one?
>
> When I get some time later I'll check your code out, what I 
> want to do is get something like
>
> string x = join(a, b, "a", "b"); to produce the same code as
> string x = a~b~"ab";
>
> (no looping using for each except for string arrays)
>
> Thanks!


Don't forget that tuples can store more than just types!  See 
this for instance.

   import std.stdio;

   typeof(Xs[0]) sum(Xs...)()
   {
       pragma(msg, Xs); // tuple(1, 2, 3)
       typeof(Xs[0]) y;
       foreach(x; Xs) y ~= x;
       return y;
   }

   int main() {
       auto n = sum!(1, 2, 3);
       enum m = sum!(1, 2, 3);

       pragma(msg, typeof(n)); // int
       writeln(n); // 6
       writeln(m); // 6

       return 0;
   }

Works great.  When I comment out the 'sum!("1", "2", "3")' and 
replace it with a literal '6', the compiled EXE is byte for byte 
exactly the same.  You can exchange the '+=' for '~=' and it will 
concatenate strings instead.  Of course, now all arguments MUST 
be known at compile time, but that's no surprise.

PS: OK, just noticed that you were hoping to mix run time and 
compile time arguments.  Oops....
Oh well, posting anyway because I think it's neat. lol

As for a~"B"~"C" compiling into a~"BC", I think we just need to 
work on constant folding in the compiler. (If it doesn't already 
do this anyway.)