DIPs

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) { }

It is not described in the betterC page as these features are not new for D. The betterC page only describes the differences versus the full D feature set. Documentation for the individual features mentioned: http://dlang.org/spec/function.html#safe-functions > array overflow checking http://dlang.org/spec/arrays.html#bounds > guaranteed initialization of locals http://dlang.org/spec/type.html http://dlang.org/spec/declaration.html#void_init > no more stray pointers into expired stack frames DIP1000 describes D's scoped pointers approach to memory safety - https://github.com/dlang/DIPs/blob/master/DIPs/DIP1000.md. This is work in progress and the document doesn't reflect latest state of things. Conceptually, scoped slices/pointers/references are similar to concept of borrowing that you guys have in Rust.

@nogc just causes the compiler to error out when a GC allocation occurs in the region marked @nogc and its call graph. You are then expected to manage memory yourself. You could rename it @c_or_cpp_style_memory_management_only. You can malloc/free (scope(exit) is useful here), use smart pointers, alloca, static arrays, use Andrei's allocators[1], or whatever else you'd use in C or C++. The answer to all of your questions is basically the same as they are in C and C++. D does have @safe though which prevents unsafe memory operations and Walter is in the process of ratcheting up the memory safety with DIP1000[2]. 1. https://dlang.org/phobos/std_experimental_allocator.html 2. https://github.com/dlang/DIPs/blob/master/DIPs/DIP1000.md

https://wiki.dlang.org/DIP25 https://github.com/dlang/DIPs/blob/master/DIPs/DIP1000.md

D is working on it, if I understand DIP1000 [0] correctly. The example would look like: struct X { Y y; scope ref Y getY() { return y; } } [0] https://github.com/dlang/DIPs/blob/master/DIPs/DIP1000.md