Re: Expanding CTFE code during compilation
On 7/23/22 2:27 PM, Azi Hassan wrote:
On Saturday, 23 July 2022 at 00:56:39 UTC, Steven Schveighoffer wrote:
On 7/22/22 3:22 PM, Azi Hassan wrote:
Oh, interesting syntax. I was thinking something along the lines of
```D
template printEnum(...) {
version(debug) {
... // everything we already did
} else {
enum printEnum(alias x) = x;
}
}
```
But I like yours better.
`version(debug)` isn't valid syntax, `debug` is a keyword.
I stand corrected, I must've got it confused with version(unittest)
And *I* stand corrected! `unittest` is also a keyword, so clearly that's
not disqualifying. Indeed, the grammar specifically includes
`version(unittest)` and `version(assert)`.
However, because `debug` is exactly like `version` in how it operates,
`version(debug)` would make little sense.
-Steve
Re: Expanding CTFE code during compilation
On Saturday, 23 July 2022 at 00:56:39 UTC, Steven Schveighoffer
wrote:
On 7/22/22 3:22 PM, Azi Hassan wrote:
Oh, interesting syntax. I was thinking something along the
lines of
```D
template printEnum(...) {
version(debug) {
... // everything we already did
} else {
enum printEnum(alias x) = x;
}
}
```
But I like yours better.
`version(debug)` isn't valid syntax, `debug` is a keyword.
-Steve
I stand corrected, I must've got it confused with
version(unittest)
Re: Expanding CTFE code during compilation
On 7/22/22 3:22 PM, Azi Hassan wrote:
Oh, interesting syntax. I was thinking something along the lines of
```D
template printEnum(...) {
version(debug) {
... // everything we already did
} else {
enum printEnum(alias x) = x;
}
}
```
But I like yours better.
`version(debug)` isn't valid syntax, `debug` is a keyword.
-Steve
Re: Expanding CTFE code during compilation
On Wednesday, 20 July 2022 at 14:11:52 UTC, Dennis wrote: On Wednesday, 20 July 2022 at 00:33:06 UTC, Azi Hassan wrote: Where did you find it though ? I checked dmd --help and man dmd before making this thread, but to no avail. It was implemented as an internal debugging tool, not a documented feature: https://github.com/dlang/dmd/pull/6556 It turned out to be useful for users as well though, and got exposure through the "AST" button on https://run.dlang.io/ Maybe it's time to document it, currently there's only this: https://wiki.dlang.org/DMD_Source_Guide#View_emitted_templates_instances_and_string.2Fmixins I see, thanks. I'll be sure to check the wiki next time.
Re: Expanding CTFE code during compilation
On Wednesday, 20 July 2022 at 01:15:44 UTC, Steven Schveighoffer
wrote:
On 7/19/22 8:57 PM, Steven Schveighoffer wrote:
There's a slight bloat in the compiler symbol table when but
other than that it should be effective.
Obviously I didn't finish that thought...
"when `-debug` isn't used on the command line"
-Steve
Oh, interesting syntax. I was thinking something along the lines
of
```D
template printEnum(...) {
version(debug) {
... // everything we already did
} else {
enum printEnum(alias x) = x;
}
}
```
But I like yours better.
Re: Expanding CTFE code during compilation
On Wednesday, 20 July 2022 at 00:33:06 UTC, Azi Hassan wrote: Where did you find it though ? I checked dmd --help and man dmd before making this thread, but to no avail. It was implemented as an internal debugging tool, not a documented feature: https://github.com/dlang/dmd/pull/6556 It turned out to be useful for users as well though, and got exposure through the "AST" button on https://run.dlang.io/ Maybe it's time to document it, currently there's only this: https://wiki.dlang.org/DMD_Source_Guide#View_emitted_templates_instances_and_string.2Fmixins
Re: Expanding CTFE code during compilation
On 7/19/22 8:57 PM, Steven Schveighoffer wrote: There's a slight bloat in the compiler symbol table when but other than that it should be effective. Obviously I didn't finish that thought... "when `-debug` isn't used on the command line" -Steve
Re: Expanding CTFE code during compilation
On 7/19/22 8:33 PM, Azi Hassan wrote:
Nice, a compile time console.log. Thanks a lot, this will come in handy.
I wonder if it can be combined with version(debug) to only run the
pragma line if compiled with -g, this way we can keep the printEnum!
line as it is. Then again, the code would become polluted by debugging
logic
Yep:
```d
debug template printEnum(...) {
... // everything we already did
}
else
enum printEnum(alias x) = x;
```
There's a slight bloat in the compiler symbol table when but other than
that it should be effective.
-Steve
Re: Expanding CTFE code during compilation
On Tuesday, 19 July 2022 at 22:41:43 UTC, Steven Schveighoffer
wrote:
On 7/19/22 5:43 PM, Azi Hassan wrote:
Just in case this is a consequence of the XY problem, the
reason why I'm looking for this is to make sure that the code
I wrote did evaluate to what I'm expecting it to. Right now I
do this with an enum assignment followed by static asserts,
but I'd love it for there to be some sort of visual feedback.
Thanks in advance
```d
template printEnum(alias x, string file = __FILE__, size_t line
= __LINE__)
{
enum printEnum = x;
pragma(msg, file, "(", int(line), "): ", printEnum);
}
enum x = printEnum!(iota(1, 5).reduce!"a * b");
```
This will spit out the file, line, and value for the
declaration. Assuming this is useful for your double-checking
you could do this, and then switch it back when you have
verified that it's correct.
-Steve
Nice, a compile time console.log. Thanks a lot, this will come in
handy. I wonder if it can be combined with version(debug) to only
run the pragma line if compiled with -g, this way we can keep the
printEnum! line as it is. Then again, the code would become
polluted by debugging logic
Re: Expanding CTFE code during compilation
On Tuesday, 19 July 2022 at 22:27:56 UTC, Dennis wrote:
On Tuesday, 19 July 2022 at 21:43:01 UTC, Azi Hassan wrote:
I'm wondering if the offers has the option of executing the
parts that can be evaluated at compile time and then replacing
them with the result of this evaluation.
Try the `-vcg-ast` flag:
```D
import object;
import std;
void main()
{
enum int x = 24;
writeln(24);
return 0;
}
// ... and a bunch of template instances
```
Thanks a lot, this is exactly what I had in mind. Where did you
find it though ? I checked dmd --help and man dmd before making
this thread, but to no avail.
Re: Expanding CTFE code during compilation
On 7/19/22 5:43 PM, Azi Hassan wrote:
Just in case this is a consequence of the XY problem, the reason why I'm
looking for this is to make sure that the code I wrote did evaluate to
what I'm expecting it to. Right now I do this with an enum assignment
followed by static asserts, but I'd love it for there to be some sort of
visual feedback.
Thanks in advance
```d
template printEnum(alias x, string file = __FILE__, size_t line = __LINE__)
{
enum printEnum = x;
pragma(msg, file, "(", int(line), "): ", printEnum);
}
enum x = printEnum!(iota(1, 5).reduce!"a * b");
```
This will spit out the file, line, and value for the declaration.
Assuming this is useful for your double-checking you could do this, and
then switch it back when you have verified that it's correct.
-Steve
Re: Expanding CTFE code during compilation
On Tuesday, 19 July 2022 at 21:43:01 UTC, Azi Hassan wrote:
I'm wondering if the offers has the option of executing the
parts that can be evaluated at compile time and then replacing
them with the result of this evaluation.
Try the `-vcg-ast` flag:
```D
import object;
import std;
void main()
{
enum int x = 24;
writeln(24);
return 0;
}
// ... and a bunch of template instances
```
