UFCS is such an underrated language feature. When you have UFCS you can toss out 90% of the uses of methods in favor of just plain ole functions. Add generic functions and concepts and you rarely end up needing OO support.

For example, function arguments can be "in", "out", "inout", "ref", "scope", "return ref" - and combinations.

Another example is conditional compilation. Great when used sparely, but can otherwise make it very difficult to understand how the code flows.

In the end, reading the source code of the standard library convinced me against it.

(The source code for the C++ standard library is much worse, of course).

One good memory I had is a couple of years ago when I built a little forum using D. Man the site was blazing fast, like the interaction was instant. Good times.

I want a meta list of all these interesting features across languages.

EDIT: I found one! “Micro features I’d like to see in more languages” https://buttondown.com/hillelwayne/archive/microfeatures-id-...

https://dlang.org/articles/exception-safe.html

In concrete, looks to me to be the only language that covers the major ways to do it.

(In concrete the `scope` way is the one I found inspiring. . I think the exceptions can go and be replace by it for langs where exceptions are removed)

In Rust land, it really need integration of something like flux into the language or as a gradually-compatible layer.

Can't have safe software without invariant checking, and not just stopping at bounds checking.

CTFE is good.

I do not really like the UFCS; if you want it to be used like a member of the first parameter then you should define it as a member of the first parameter (possibly as a inline function that only calls the freestanding function with the same name, if that is what you want it to do). (You could use a macro to do this automatically if you want to.)

Scoped imports is good, but I think that scoped macros would also be helpful.

Exhaustive switch seem like it might be better if designed differently than it is, but the idea seems to be not bad, in general.

    pure nothrow @nogc: 

    pure:
    nothrow:
    @nogc: 

    pure nothrow @nogc
    {
        block
    } 

The ironic thing about this is that it means that the public functions of an object can't, generally, call each other willy-nilly unless they take special precautions: very often, the object's invariants are broken when the execution is in a middle of the object's method. This is not a problem with D, the language merely helps you to uncover this lurking problem which usually simply goes unnoticed until something breaks and someone notices it.

There were some efforts to enable D on the web but it seems like these are mostly one man efforts that implement only the minimum features that their specific projects required.

Can someone give me an update about the current state of this?

The current LSP is _that_ bad, it doesn't even recognize most notable D features such as templates and named arguments..

This should be their #1 priority, as the language is starting to get steam again, they should not miss tat opportunity

I know Walter does not use that kind of tools, but that's becoming a requirement nowadays for young developers

Please, invest into tooling!

D was so far ahead of C++98 that it wasn't funny, but garbage collection kept it from being able to be used in the same niche.

D has gotten less dependent on garbage collection but

C++11 (and then 17, 20, 26 (reflection)) have closed the gap enough that it is not the quantum leap that it once was.

> Structs and classes can even overload this operator

nope. fuck, now it's a terrible idea

(come on, a low effort joke now and then is ok, if not for anything else, as an counter-example)