I just finished sections 24 to 36 of chapter 4 of the Rust book. Here’s what I felt:
- Associated types seem like an improvement over generics. They seem like an important concept to write effective Rust code and I wish that this chapter had gone into more details and had a larger example.
- Rust supports macros. As the chapter mentions, I probably wouldn’t write one unless I absolutely had to. If Rust supported variable number of arguments to functions one could probably implement
vec! using that plus generics.
unsafe seems like a very powerful and tricky Rust feature. I wish the chapter had an actual example that demonstrated how to use
unsafe correctly. And also an example of when not to use
unsafe — for example when you’re writing bad Rust code and using
unsafe to mask a bad design.
(You can find my thoughts on the previous chapters / sections here)
I spent the past few days working through the first 3 chapters and the first 23 sections of chapter 4 of the Rust book. Here are my initial thoughts on Rust:
- Cargo is pretty sweet. It’s an easy to understand build and dependency management system. Even though I’m only using it for simple things so far I’m really happy with it and have not run into any issues. I’ve also gotten very used to running
cargo new <project_name> [--bin] to start new Rust projects.
- Compared to Go, Rust is a much larger language, with many more concepts to learn. Go is a simple language to learn. I feel that Rust has a steeper learning curve.
- Memory safety is one of Rust’s strongest selling points. It is one of the trickier concepts to understand and is unlike anything I’ve experienced in C, C++, Java, Go, Python, etc. I’d say the concepts that come close to resembling it are
shared_ptr in C++11. Consequently I spent the most time on the three sections dedicated to references and borrowing, lifetimes, and mutability. Most of the bugs that I ran into while writing Rust code were also related to these concepts.
- Rust has generics. This was something I missed in Go.
- I haven’t gotten used to writing functions without an explicit
- The Rust book is very well written but there are a few areas of improvement. My major gripe is that it introduces new language constructs but doesn’t explain what they do. For instance the chapter on trait objects introduces the
format! macro for the first time without explaining what it does, the chapter on closures uses a
Box to return a closure from a function without going into what exactly a
Box is etc.