On Monday, 22 July 2013 at 16:48:56 UTC, Jesse Phillips wrote:
On Sunday, 21 July 2013 at 07:22:08 UTC, JS wrote:
void foo(T...)(T t)
{
pragma(msg, B(t));
}
void main() {
foo("x", "a", "b");
din.getc();
}
does work. I need to have B generate compile time code so it
is efficient. Your method calls an actual function at runtime
so it is nearly as fast as it can be.
My method doesn't make any calls, your foo is a called at
runtime. There is no way to observe a function at compile time;
ctfeWriteln does not exist.
Also don't stringof variable v (I assume you want the value and
not the symbol concatenated.
template B(T...) {
string B(T b) {
string s;
foreach(Type; T) pragma(msg, Type.stringof);
foreach(v; b) s ~= v;
return s;
}
}
string foo(T...)(T t)
{
return B(t);
}
void main() {
enum forced = foo("x", "a", "b");
pragma(msg, forced);
din.getc();
}
I don't think you understand(or I've already got confused)...
I'm trying to use B has a mixin(I don't think I made this clear).
I can't use it as a normal function. e.g., I can't seem to do
mixin(B(t)). If I could, this would definitely solve my problem.
Here is a real world example:
template VariadicLoop(T...)
{
pragma(msg, T);
string VariadicLoop(T t)
{
string s;
foreach(k; T)
s ~= k.stringof;
foreach(v; t)
s ~= v;
return s;
}
//enum tVariadicLoop = eval();
//pragma(msg, tVariadicLoop);
}
string join(T...)(string delim, T t)
{
return mixin(VariadicLoop(t));
}
VariadicLoop should join the strings passed to join(producing
whatever code is necessary to do this efficiently.
e.g.,
join(",", "a", s) should result in the code for join:
{
return "a"~","~s; // s maybe t[1] or something
}
This is the most efficient way to join rather than using a
foreach over an array of strings or something or another.
(VariadicLoop could handle string[]'s and insert the appropriate
code to join them)
The goal I'm trying to solve is efficiently deal with variadic
arguments that are compile time calculable along with mixing in
the runtime aspect. Basically: get the compiler to do all the
work it can before having it done at runtime. if we are passing
string literals to join then they can be joined at compile time.
If we are passing a combination of string literals, string
variables, and string arrays then we deal with each part
efficiently as possible.
