Top: As someone who comes from a C++ background, rust feels like it was expressly designed to address its flaws while keeping a similar performance model:
- memory safety: of course there is the ownership system, that reifies what I had been doing manually in
C++for years, and that was reliant on documentation to express the lifetime relationships between objects (with the possibility for bugs, or some tradeoffs with copies when the risk is too high). but memory safety in rust is so much more than that. No longer do I have to take extreme care with "rule of five" shenanigans because my class implements RAII. I no longer suffer from fields uninitialized by a buggy constructor. I don't accidentally pass a temporary instead of a reference to a class because I typo'd and left out the&in the return type of a getter (that particular segfault was painfully stupid). Where it matters, I can mark functions and traits as unsafe to signal clients that they should look for additional preconditions in the documentation should they use them. These parts of the code where memory safety isn't enforced by the compiler stand out with unsafe blocks. - compilation model: not relying on textual inclusion but having a package system allowing to add dependencies in a declarative manner is a very welcome simplification from CMake. Allows more aggressive inlining, and also use of items independently of declaration order.
- module system: handling privacy at the module boundary rather than at the class boundary is much more flexible and comes in handy for e.g. unit tests, or for patterns where some objects are strongly coupled by design (e.g. builders)
- option type to express the possibility of absence. I use
std::experimental::optional(C++14) extensively, but the ergonomics suffers from the lack ofmatch, and the presence of nullable pointers is redundant - result type comes to fix
C++'s broken error story, where the ecosystem is split between exception users and non-users (the replacement being error codes, or various home-made error systems). I rolled up my own result implementation inC++, but it is home-made, suffers from the lack ofstd::variantinC++14, has worse ergonomics and I still have to use whatever my dependencies chose for error handling when interacting with them. - more generally, I miss rust
rustenums all the time. I wonder why the simple concept of "can be A or B" took untilC++17to come, and only as a library type. - traits as interface: allows for templates that are much easier to use (not "write-only"). This pushes a style with lots of monomorphizations that is hard to achieve in
C++for various reasons (such as the compilation model) and is unified with runtime polymorphism through trait objects. - iterator trait that is easy and safe to implement, and come with lots of adaptors that are helpful for all iterators. No longer do I have to go through so much boilerplate while treading carefully for memory errors whenever I need to define a custom iterator
- zero-sized types: allows to express compile time properties with zero runtime cost.
- Generally, good defaults: memory safe by default, explicit conversions by default, immutable by default, objects movable but not copyable by default
Flop: The language is young, inertia in this space is high (billions of lines of code have been written in C++). As a result, I find myself missing some dependencies in rust (qt, an equivalent to boost::icl::interval_map), and if we wanted to integrate rust to our existing codebase, we would have to rely on FFI while our C++ codebase makes extensive use of templates and so isn't ffi friendly. This without accounting for the cost of building the same level of expertise in rust as in C++... Also as a result of its youth, I find myself missing some features (some of which may land this year): const generics (parameterising a template by an enum), variadic templates (which we use for implementing services with compile time checked arbitrary signatures).
I don't mean to pick on C++, I still think we can build excellent software using that language (hopefully, this is what we are doing!), but Rust just happens to fix many of the hindrances I encounter in my usage of C++.