D vs Rust

[Guillaume Piolat via Digitalmars-d]

On Thursday, 28 January 2016 at 22:30:51 UTC, nbro wrote:
> I have loved C++ when I first started learning it a pair of 
> years ago (then I stopped for some time for some work reasons), 
> and quite recently I have discovered D, which seems apparently 
> a better language from the design point of view, especially in 
> supporting OO design and modularisation, maybe I am just wrong 
> since I know just a little of D so far, but I really had some 
> problems just in setting up a simple OO project, i.e. importing 
> classes, there are .h and .cpp files, etc, which only make 
> everything confusing and make you learn stupid things instead 
> of being productive. D also seems to have a cleaner syntax in 
> general. C++ is becoming more and more a mess because they keep 
> introducing new functionalities to make C++ compete with new 
> languages, and I'm starting hating it. Languages should not 
> just be powerful but simple enough to be productive.
>

> Apart from this, what are the real advantages of D over Rust?

In my uninformed opinion (I've not used Rust more than "hello 
world").

For D:

- no strong feelings against D syntax, it's rare that people 
complain about it. Rust syntax is more controversial. This 
shouldn't matter, but it does.

- D "duck-typed" meta-programming could well be more applicable 
than traits-based meta-programming. Need less names and 
complexity.

- using "unsafe", Rust isn't particularly more memory-safe than 
the @safe D subset. Which by and large native programmers don't 
even care that much. Top concerns with C++ would be compilation 
times or build complexity. D kills most memory safety concerns 
throught bounds check, slices or default initialization.

- Rust error handling doesn't strike me as working at scale. We 
are already seeing "You should not do .unwrap() in a library" 
advices from Rust experts. Yet .unwrap() seems to creep 
everywhere which conflates input errors and logical bugs.

- D has defaults that let you write ugly code. I think it's a 
positive. Why should you care about memory safety or immutability 
for a 50 line program? Cost vs benefit. You can always enforce 
later, but you don't get your time back.


For Rust:

- Rust has a simpler resource story. Using it is similar to using 
modern C++ correctly, hence the appeal for many C++ers who feel 
at home conceptually.

- cargo is a bit friendlier than DUB, and less controversial in 
its community (which is imho generational, seeing like C++ 
package managers are even more controversial). Maybe the package 
manager / build tool is the primary interest of Rust and D over 
C++.

- You can do composed RAII in D but using (GC + linear types) is 
more complex than using linear types.

- D is a large language, not sure how much relatively to Rust. 
I've heard Rust is complicated too.