On Wednesday, 15 March 2017 at 03:40:42 UTC, ag0aep6g wrote:
On 03/15/2017 03:01 AM, Inquie wrote:
If I do something like
enum X = Methods!(C);
foreach(x; X)
{
mixin(x);
}
I get an error about x not being a compile time variable.
(code above is
simplified, the error has nothing to do with the form but of
the
foreach(x )
"Compile time variable" may be misleading here. The compiler
does not try to figure out what values are actually constant at
compile time. Rather, the language defines some specific cases
where it's guaranteed that a value is a compile-time constant.
Only then can you use it in static contexts such as mixins.
Other values are rejected, even if they would turn out be
constant on a closer look.
`foreach` is mostly a run-time feature. There is a special case
when you iterate over a "compile-time list" [1] (aka AliasSeq,
formerly TypeTuple). In that case, the loop variable is
recognized as a constant. That variant of `foreach` is also
dubbed a "static foreach" (even though the `static` keyword is
not used).
Note that it's not a "static foreach" when you iterate over an
array, no matter if that array is constant at compile time or
not.
So this works:
import std.meta: AliasSeq;
foreach (x; AliasSeq!("int foo;", "double bar;")) mixin(x);
But this doesn't:
foreach (x; ["int foo;", "double bar;"]) mixin(x);
This is expected and works as intended. Without the definition
of your `Methods` template, I can't say for sure if you're
hitting this or if something else is going on. But if your `X`
is an array, this is it.
but if I wrap it in a function it works
string foo()
{
enum X = Methods!(C);
string y = "";
foreach(x; X)
{
y ~= x;
}
return y;
}
mixin(y);
(I'm assuming that last line should be `mixin(foo());`.)
The return value of `foo` is recognized as a compile-time
constant there, because you call it in a context that forces
it. This is called CTFE.
Note that you cannot assign the result of `foo()` to a variable
first:
string y = foo(); /* no CTFE */
mixin(y); /* no go */
That's because `y` is a normal variable, which is not a
recognized compile-time constant. The value could of course be
evaluated at compile-time, but the compiler doesn't attempt
CTFE opportunistically.
The only diff, of course, is the foreach in the first case
mixes in on
each iteration, while in the second it doesn't... but it
shouldn't
matter. in both cases x is the same.. and it definitely is a
compile
time constant in both.
To the compiler it's not a "compile-time constant" in either of
them (in a rather specific sense of the term "compile-time").
During CTFE, run-time rules apply. So in `foo`, `x` is a normal
variable. The same rules apply as for actual run-time
variables. Only the return value of `foo` is seen as a
compile-time value by the compiler.
You're not the first one who stumbles over this meaning of
"compile time". CTFE happens at compile time, and has "compile
time" in the name, but during CTFE you're actually dealing with
"run time" values that might never see the actual run time.
Maybe these things could use some better names.
[1] https://dlang.org/ctarguments.html
Thanks, it explains it, but there is one difference. The array is
assigned to an enum, so surely the compiler can figure that out?
It should be similar to AliasSeq. I could probably wrap AliasSeq
around it and it work or convert it to
an AliasSeq. Seems like an issue with the compiler.
Remember, it's
enum X = Methods!(C);
foreach(x; X)
{
mixin(x);
}
and not
string X = Methods!(C);
foreach(x; X)
{
mixin(x);
}
that should be quite difference and the static foreach in the
first case and non-static foreach in the second.
Essentially what you are saying is that if I were to have
Methods! return an AliasSeq then it would work. It is a CTFE that
returns an array. If there is a function that can convert the the
array to an AliasSeq of tuples there should be no problem,
although I don't see how to do that, it should be possible?
But, this all then seems to be skirting the fact that the loop is
still over a compile time constant(enum or AliasSeq, shouldn't
matter) and should work.
