Value of type enum members

[Petar]

On Tuesday, 19 January 2021 at 20:27:30 UTC, Andrey Zherikov 
wrote:
> Could someone please explain why there is a difference in 
> values between compile-time and run-time?
>
>
> struct T
> {
>     int i;
>     this(int a) {i=a;}
> }
>
> enum TENUM : T
> {
>     foo = T(2),
>     bar = T(3),
> }
>
> void main()
> {
>     pragma(msg, TENUM.foo);    // T(2)
>     pragma(msg, TENUM.bar);    // T(3)
>     writeln(TENUM.foo);        // foo
>     writeln(TENUM.bar);        // bar
> }

TL;DR `pragma(msg, x)` prints the value of `x` usually casted to 
the enumeration (base) type, while `std.conv.to!string(x)` prints 
the name of the enum member corresponding to the value of `x`.

Both `pragma(msg, ...)` and `std.conv.to!string(..)` (what is 
used under the hood by `writeln(..)`) take somewhat arbitrary 
decisions about formating enum members, neither of which is the 
"right" one, as there's no rule saying which is better.

In general, `std.conv.to!string(..)` tries to use format that is 
meant to be friendly to the end-users of your program, while 
`pragma(msg, ...)` is a CT debugging tool and it tries to stay 
close to the compiler's understanding of your program.

For example:

void main()
{
     import std.stdio;

     enum E1 { a = 1, b, c }
     enum E2 { x = "4" }
     enum E3 : string { y = "5" }

     // 1.0 2L cast(E1)3 4 5
     pragma(msg, 1.0, " ", long(2), " ", E1.c, " ", E2.x, " ", 
E3.y);

     // 1 2 c x y
     writeln(1.0, " ", long(2), " ", E1.c, " ", E2.x, " ", E3.y);
}


End-users generally don't care about the specific representations 
of numbers in your program, while on the other hand that's a 
crucial detail for the compiler and you can see this bias in the 
output.