anyhow, once I understood that unique_ptr meant nothing like its name but rather something like auto_free_pointer, the pieces sort of fell into place and I experienced almost no memory safety bugs while implementing the compiler, nor has afl-fuzz found any so far 4/5
Conversation
this is all despite my being a thoroughly mediocre C++ programmer. anyhow this story has no real point except that unique_ptr is actually pretty cool and useful, which I had not expected 5/5
11
5
97
Replying to
So good that, in my quite limited understanding of Rust it sounds like everything nontrivial by default is basically a unique_ptr.
2
2
The static enforcement of rules for move semantics and reference aliasing/lifetimes is the interesting part.
Box<T> benefits from those in the same way as any other type. It's quite boring in the Rust world. Any type with a destructor has similar semantics.
1
2
A major difference from C++ in Rust is that assignment, passing and returning values works like C. If the type has a destructor, those have move semantics. A non-trivial copy is done by calling clone explicitly. Rust code uses far more moves and lot more lightweight references.
2
3
I really need to start writing Rust, but it always seems that there's something more pressing to learn
1
2
I don't think you'll really have as much to learn as you think.
As a C++ programmer with a deep familiarity with how memory corruption happens and the semantics you need to avoid it, you largely have an informal and imperfect form of Rust's borrow checker in your head already.
2
4
The main you need to learn is not really syntax, semantics, etc. of the language and libraries. That all comes quite naturally... but rather, you need to learn the idioms needed to work around the static checking. You want to do something and it won't let you. Need to satisfy it.
2
3
this is my experience writing OCaml, where there's always a simple way to do what I want but it takes me all day to find it
1
2
Need experience to figure out how to do it in an efficient, simple and clean way with lots of moves, lightweight references, sum types, etc.
You largely know what you need to use Rust already but you have to learn how to avoid resorting to Rc<RefCell<T>> which is not pretty.
Instead of dealing with Rc<T> and Weak<T> for a graph with cyclic references, there are other options like putting the nodes in an arena so they all have the same lifetime.
Also stuff like destructuring with let / match to get multiple non-overlapping mutable references, etc.
1