I've not used Rust, but don't plan to.
On Wednesday, 22 July 2015 at 18:47:33 UTC, simendsjo wrote:
While code.dlang.org has 530 packages, crates.io has 2610
packages,
I think this tells something foremost about the size of the
community. More people leads to more code.
Traits
------
I think the ability to express an interface without buying into
inheritance is the right move. The alternative in D is
specifying the behavior as a template and verifying the
contract in a unittest for the type.
Traits can't do Design by Introspection aka compile-time duck.
C++ can on the other hand.
Algebraic data types
--------------------
Haven't looked into `Algebraic!`, so I won't start bashing D
here :) But given the lack of pattern matching, I doubt it will
be as pretty as Rust.
You can pattern-match with visit.
Macros
------
I haven't written more than extremely simple macros in Rust,
but having macros that is possible for tools to understand is a
win. Templates and string mixins is often used for this
purpose, but trying to build tools when string mixins exists is
probably extremely hard. If D had hygenic macros, I expect
several features could be expressed with this instead of string
mixins, making tooling easier to implement.
There is a difference though: Rust forces macros on you on the
get go, while in D string mixing are quite a rare occurence
thanks to other meta things and don't have a weird separate
syntax. Regular templates + tuple foreach + static if is just
easier to debug.
Borrowing
---------
This is probably the big thing that makes Rust really
different. Everything is a resource, and resources have an
owner and a lifetime. As a part of this, you can either have
multiple aliases with read-only references, or a single
reference with a writeable reference. I won't say I have a lot
of experience with this, but it seems like it's not an
extremely unergonomic trade-off. I cannot even remotely imagine
the amount of possible compiler optimizations possible with
this feature.
The problem I see with this is that it is exactly like C++ scoped
ownership except enforced. Even in Rust meeting they said they
were converging on C++. It remotely feels like the same language
to me.
I've worked in fully scoped ownership codebases, it's very nice
and consistent, and you don't feel like you would need anything
else while doing it. You must train everyone to do it. Enforcing
it in the language? I'm not sure about this. There are time where
you debug and you have to comment stuff out wildly.
Also if you are going to replace C++, it is a given to at least
compile faster, make solve problem #1.
