DIPs

Little by little, Rust, like D, acknowledges that C++ flexibility regarding object construction, copy and move, even if too much as a default, is sometimes needed :) I saw in D years ago how they also checked into this flexibility after getting some use cases for it (in this case, copying): https://github.com/dlang/DIPs/blob/master/DIPs/accepted/DIP1...

The reference compiler, DMD, is open source: https://github.com/dlang/dmd But they don't accept just any Pull Request or features the community submits, understandably. There's a process called DIP for language improvements: https://github.com/dlang/DIPs/blob/master/DIPs/README.md However, by some accounts, it's really hard to get anything through. Given D already has so many features, I find that to be a good thing, to be honest, but not everyone agrees, of course.

There's no "nogc" containers in phobos, or allocators, or an idiomatic way to do safe manual memory management. It expects you to do it the C way. It's also impossible to implement some things because of how D does moving. There's a DIP in the works to change how moving works, but it's overly complicated and bound to introduce even more bugs. https://github.com/dlang/DIPs/blob/master/DIPs/DIP1040.md

https://github.com/dlang/DIPs/blob/master/DIPs/other/DIP1008... Exists as a preview switch

This is quite interesting, a very elegant struct hack. Dlang is working on an RFC for implementing this feature right into the language, which would probably make it the first systems language to implement this without structs. https://github.com/dlang/DIPs/blob/master/DIPs/DIP1030.md

DIP1021 is one step toward a larger goal outlined in the blog post 'Ownership and Borrowing in D'. What are the next steps? https://github.com/dlang/DIPs/blob/master/DIPs/accepted/DIP1...

D is not clean. It already has some cruft. For example, there should be no "@safe" annotation but an "@unsafe" one. Unfortunately, D picked the wrong default back then. Ok, "in relation to C++" it is clean. :) Edit: There is a proposal to fix it: https://github.com/dlang/DIPs/blob/master/DIPs/DIP1028.md

One can also use D (now part of GCC). D with its better dialect allows one to not use D run time libraries, or even C++ runtime libraries. A developer can just choose what C libraries they want to link with. In this mode, no GC is provided, so a developer will be using manual allocation. With upcoming D's dip1000 feature, it will be able to do rust-like borrows checker at compile time (or at least this is my understanding). And that capability will be available in betterC mode as well (not just for full blown D). The code in betterC can use generics and other advanced features https://dlang.org/spec/betterc.html --- Nearly the full language remains available. Highlights include: - Unrestricted use of compile-time features - Full metaprogramming facilities - Nested functions, nested structs, delegates and lambdas - Member functions, con

That is what the part of this idea that Walter is tackling first, See https://github.com/dlang/DIPs/blob/master/DIPs/DIP1021.md The short of it is that the compiler will enforce that the same pointer is not provided to function more then once at the call site.

Rust achieves memory safety without a tracing GC. D has traditionally relied on the GC for that, but now there's [DIP1000](https://github.com/dlang/DIPs/blob/master/DIPs/DIP1000.md). D can however be used without a GC if needed. Rust has macros, which D doesn't, but D's metaprogramming is superior. They're both fine choices.

The original syntax for lambdas in D worked, but it was so clumsy nobody used it, and people even said "D doesn't have lambdas". Changing it to a much simpler syntax changed everything. old: function double(double a, double b) { return a + b; } new: (a, b) { return a + b; } Currently, the syntax for in/out contracts is being revised for usability: https://github.com/dlang/DIPs/blob/98052839441fdb8c6cc05afcc... D has a different syntax for templates than C++, and is far more approachable and convenient: C++: template<class T> void foo(T t) { } template<class T> class S { }; D: void foo(T)(T t) { } class S(T) { }