C++ Insights – See your source code with the eyes of a Compiler

I second this.

You can see it by typing in the sample code in the tool here - https://news.ycombinator.com/item?id=49928362

Lambdas in D are just nested functions:

    int foo(int i) {
        int add(int x) { return i + x; } // nested function
        return add(3);
    }

    int bar(int i {
        alias lambda = (x) => x + i;  // lambda
        return lambda(3);
    }
    }

C++ lambdas are just structs that overload operator(); once you realize that they become a lot less mysterious. But it's a great example of how this tool is useful to learn about those things (of course you could also read the C++ standard but who has time for that?)

Here's an example: https://cppinsights.io/s/f04b6896

(That also shows how C++'s range-based for-loops work, which is similarly some syntactic suger for a fairly mundane for-loop, but details are interesting: unlike a typical for-loop, the loop variable is declared inside the loop body.)

I don't think it's only C++ though, Python decorators, Rust macros, almost every language's compiler write code you never see. C++ just does more of it and makes it harder to guess. Being able to look at the expanded version is useful in any language that does this.

No a language doesn’t need it. It’s an educational tool for those new to the language or new to a particular language feature. With practice language features just become automatic so you don’t think about them when thinking about a problem.

In the README example, the C++ practitioner just doesn’t think about those automatically synthesized copy constructors and such for POD types, nor do they think about the fact that assignment is desugared to operator= or that an assignment can involve a static_cast.

In what language is compiling simple? Do you not like compiled languages? I'm not sure what you're complaining about here.

You have misunderstood the language and the tool.

Compilers for all languages have the concept of "lowering" the level of source-language abstractions from high-level to low-level viz. Written Source -> Simpler Source -> AST -> IR -> Machine Code. One type is "desugaring" i.e. transforming complex syntax to simpler ones so that the following stages of compilation have to operate only on a smaller and hence more manageable language subset.

This tool shows both desugaring and other lowering (eg. implicit transformations, type deductions etc.) within the C++ source language by regenerating the source from the AST thus giving you full visibility until that stage in the compilation process.

PS: Explanatory video presentation by the author - https://www.youtube.com/watch?v=VJ6ZvDRYzNE&t=558s

Which language do you think doesn't need it? For instance for me I wish I had such a tool whenever I used any interpreted or JIT language, to understand clearly to which semantics whatever is happening maps and how their respective front-end optimizes. Things as simple as "a" + "b" in JavaScript: are you sure you know how every js runtime maps it? Do they fold the strings as an optimization during parsing ? Do they preallocate a larger native string type and push? Do they just do something that ends up an equivalent of std::u16string("a") + std:: u16string("b")?

Good for C++'s coroutines too

This is very different and doesn’t relate to what the linked repo does.