On Monday, 19 August 2013 at 04:37:58 UTC, captaindet wrote:
On 2013-08-17 21:54, JS wrote:
On Sunday, 18 August 2013 at 00:17:22 UTC, captaindet wrote:
On 2013-08-17 14:36, Jesse Phillips wrote:
Third you've declared a variable, bar, which will store your
enumerated value, 4. Variables are not compile time, even if
the
value stored came from a compile time known value.
yep, it completely escaped me that these are 'normal'
variables.
and i have realized now that i can make them known at compile
time
the same way as is done for other 'normal' variables, by
declaring
them const ;)
But if they are const then what good does that do you? Just
use an
alias or enum in the first place?
to be honest, i have not found a use case ;)
highest priority was that i understood what was going on here...
how did i get there? i was looking for an easy way to get
pragma(msg,...) to print the given name for an enumerated
value. in this example test2 or test4 instead of 2 and 4 - just
like write is doing it at runtime. so i was playing around with
the different variants of enum to see if i could get it working
somehow.. and got sidetracked....
in the end i stuck to manifest constant enums storing the
enumerated values and found that
pragma( msg, to!string(foo) );
is doing the trick.
/det
I had the same issues, it is not an issue with logic but with the
weird way dmd works(pragma is handled very early on and before
ctfe's are completely parsed).
Remember you can use ctfe's to format strings any way you want
and even do logic and other stuff but you can't use pragma's
inside the ctfe on ctfe variables(because as far as pragma is
concerned, they are run time at that point).
module main;
import std.stdio, std.conv;
template foo(alias T)
{
string foo(string s)
{
string x = to!string(T) ~ s ~ "yyyy";
//pragma(msg, x); // pragma see's x as a run time variable(or
rather pragma is executed before x is truly defined)
return x;
}
}
int main(string[] argv)
{
pragma(msg, foo!("asf")("xxx")); // note, it prints what the
commented pragma is suppose to print, but this one works!!!
Because it is outside the ctfe and foo!(...) can be computed at
compile time
readln();
return 0;
}
I really believe the issue is with the compiler and is a bug.
Somehow x gets marked as run time, probably because ctfe's are
suppose to work at run time too... even though in this instance
it is being used at compile time. (so it should work)
