On Friday, 5 April 2024 at 14:41:12 UTC, Carl Sturtivant wrote:
On Friday, 5 April 2024 at 07:37:20 UTC, Paolo Invernizzi wrote:
pragma(msg, x) ?
No.
`__ctfeWrite(x)` is executed inside an executing function like
any other statement in it, and can have an argument `x`
computed during that execution.
It is defined to output the computed text `x` to stderr when
the function it is a part of is called as CTFE by the compiler
and to be a no-op if that function is called at run time in the
compiled executable.
So it is a replacement for `std.stdio.write` in a CTFE
function, handy among other things for reporting what's going
on during the execution of that function by the compiler.
`pragma(msg, x)` works during its *compilation*, so putting it
as a line in a CTFE-called function would not execute it when
the function is called by the compiler. That being the case,
`x` may not be a value computed when that function executes.
Such a value is "not available at compile time", only at CTFE
run time. The CTFE function is not running when it is being
compiled.
It is possible that `x` in `pragma(msg, x)` be computed with a
call to a function as its return value, i.e. computed by CTFE,
but that call will be made when `pragma(msg, x)` is compiled,
and is a part of compiling it. Only when the function has
returned producing `x` does the `pragma(msg, x)` do its work.
This works:
```d
alias E = double;
auto r = 0.iota!E(1,.05)
static this()
{
alias ranges = imported!"std.meta".AliasSeq!(isRandomAccessRange,
isForwardRange, isInputRange, isOutputRange,
isBidirectionalRange);
static foreach(R; ranges) pragma(msg, R!(typeof(r), E));
}
void main() {}
```
SDB@79
