On Wednesday, 23 November 2022 at 21:17:42 UTC, ryuukk_ wrote:

I’d definitely give that a read. Looking forward to it 👍.

On Wednesday, 23 November 2022 at 22:07:01 UTC, Guillaume Piolat wrote:

When you say ‘shown wrong’ do you mean they’re hard to read (wrong format, mangled names) or that the values are wrong? Do you know if there are bugs reported for that problem?

I'm developing my engine literally on Windows since the start, and I'm even doing Xbox development for it, so, I think my experience with D should prove useful.

• The only time I found this missing was in a bug I just sent on issues.dlang: when using with anonymous classes inside functions, that seems to be a bug on DMD itself.

• Never here

• Nope

• I haven't actually debugged this kind of code

• Or you can use -mixin=targetFileToMixin.d, which makes it a lot easier to understand what is causing that. All the metaprogramming facilities in D doesn't work correctly in all its tooling such as code-d or VisualD.

• I would not play with instruction pointer, so unsafe to do in any language

• Yes, I actually got a problem like that when dealing with libraries, static if + versions.

• Currently for me it is quite the opposite, I can't build DLLs correctly with LDC, and when building with LDC, my writeln/printf becomes really buggy.

• BetterC bad

• Which documentation? Most of the time I could not find was when I didn't read the documentation correctly and someone was able to point to me

• I have documented a bug related to that

• Never had

• Agreed, if you can put case with static foreach, you should be able to put else if

Summary:
I can see the guy over there made 58KLoc of pure template, metaprogramming and CTFE abuse. 60 seconds of build time is just unacceptable. I do believe though that a project like that is a nice case study for D to evolve itself.

Unfortunately, it is sad to see that D is quite in that state on its unique features, like being advertising with CTFE and not being able to actually use CTFE because it can slow the build quite a lot (there was a CTFE cache PR somewhere, saying that it was able to make it build much faster, unfortunately, it didn't go onwards dunno why).

Although I would not switch D for another language, I don't completely disagree with what is said in that blog. And that is what I and some other people says: adding new features to D should not be priority n° 1, cuz there is a lot of other broken things over there that just ruins the developer experience.

Having a clear and better compilation flow with version/static if/mixin template/mixin, generating better debug information on metaprogramming side (which could also help tooling such as code-d and visual D), and after that, making CTFE faster (or cached) could make D better in what D offers.

If you code D like C or Java, you won't have much pain with it, but if you start using mixin template/alias and other features such as that, you'll start to be bitten.

On Thursday, 24 November 2022 at 11:37:57 UTC, Hipreme wrote:

This is not a case of "if doesn't work with this normal feature", it's a case of "case is extremely, extremely strange." Case statements work much more like goto labels than statements. For instance, this is valid code:

import std.stdio;
void switchtest(int i, bool b)
{
    switch (i)
    {
        case 1:
            if (b)
            {
                case 2:
                    writefln!"Case 1b or 2: %s, %s"(i, b);
                    return;
            }
            break;
        default: break;
    }
    assert(false);
}

void main()
{
    switchtest(1, true);
    switchtest(2, false);
}

On Thursday, 24 November 2022 at 12:04:27 UTC, FeepingCreature wrote:

import std.stdio;
void switchtest(int i, bool b)
{
    switch (i)
    {
        case 1:
            if (b)
            {
                case 2:
                    writefln!"Case 1b or 2: %s, %s"(i, b);
                    return;
            }
            break;
        default: break;
    }
    assert(false);
}

void main()
{
    switchtest(1, true);
    switchtest(2, false);
}

Ie. to explain what's happening here:

The syntax tree structure of if/else is if (EXPRESSION) STATEMENT [else STATEMENT]. static foreach does not match else, so it fails to parse.

The syntax tree structure of switch/case is not, as you would expect, switch (EXPRESSION) { [case EXPRESSION: STATEMENT*]* }.

Instead, it's switch (EXPRESSION) STATEMENT and STATEMENT = ... | CASE_STATEMENT, CASE_STATEMENT = case EXPRESSION:, where the CASE_STATEMENT is semantically (not syntactically) verified to occur inside switch, with no other restrictions on their placement. That's the only reason it works with static foreach.

(All parse rules made up from memory, not taken from the spec.)

On Wednesday, 23 November 2022 at 17:20:54 UTC, Kyle Ingraham wrote:

Does this make sense to anyone without elaboration:

Can't say I've ever noticed anything like that suddenly springing up, certainly not 90% of the time.

On Wednesday, 23 November 2022 at 23:44:48 UTC, Kyle Ingraham wrote:

Wrong.
btw this sort of things also happens in C++

I don't know. When this happen, I change the debugging engine or rebuild, and it makes it work. I also have disabled semantic analysis and completion because it crashed often or took too much memory.

On Wednesday, 23 November 2022 at 19:42:22 UTC, Johan wrote:

I'm very interested in seeing how using Jai turns out for this guy, but I was wondering about this too... Just what kind of code has he been writing to cause D to take a whole minute to compile?? Is he compiling each D file separately? I can understand the rest of his criticisms but I think this problem may be solely his own, even if our CTFE engine and template instantiation isn't the fastest.