Rust is easy to learn by reading (in order to understand programming concepts unique to the language, such as the borrow checker and lifetimes), but Rust is hard to learn by experimentation alone (trying 100 different syntax variations to see what compiles).
If you want to understand what Rust is mostly about, perhaps watch the "Firehose of Rust, for busy people who know some C++" video[2].
I'm mostly a Python programmer (10 years), and spent a night last week reading the first ~8 chapters of the Rust book, and working slowly through the rest.
I confirm that it's a great book, easy to read, even if reading isn't usually your style of learning. Or you can jump in and look at the Rust by Example book.
I wanted to read through at least the bits that would be totally new and confusing to me in Rust - ownership, variable lifetime, references, etc.
I'm finishing up Chapter 10 and probably getting to the point where I'll need to start actually using the language to learn it, knowing there will be gaps to fill in later. I think Rust is such a broad language that it's probably better to start coding and cementing the basics instead of trying to learn everything all at once.
The stuff you mentioned are the key points, it is where Rust really diverges from other languages (also traits, enums, smart pointers).
I read those parts and started coding, and ended up coming back to later chapters (and re-reading stuff that I didn't get fully until I started coding).
Imo, it isn't possible to read a book and actually understand what Rust is like (as may be possible with a lower surface area language like Go or Lua). I am about a year in and I am still learning about how the safety features of Rust dictate the structure of your language (i.e. pure functions, not passing references around everywhere, quite anti-OOP, what std library traits to implement).
I came from Python/Java, and the first thing I did was try to code the same way (creating smart pointers everywhere). Actually coding in Rust helps you understand when these approaches aren't good.
I haven't actually read anything that really explores this aspect of Rust. When to use enums, when to use std library traits (From/Into, particularly), when to use smart pointers were also quite important for me (Jon Gjengset has a lot of interesting on this on YouTube, his book is also great).
The book is really good, but unless you absolutely love reading technical material I contend you should not read it cover to cover. Read what you might need to solve your current issue and keep doing that until you no longer need it, sure. Anything more just kept sending me to sleep until I said "fuck it" and just started writing things that are useful.
I like "the book", but I felt more prepared for the real world after reading the O'reilly book, 2nd edition. That was sufficient for me to write any code I needed. If you want a deeper understanding, "Rust for Rustaceans" is a great book (disclaimer: I only read about half of it - too busy coding :-)
Its a very comprehensive book but takes some dedicated effort to get through. It goes through most (all?) important concepts from barrowing to iterator traits to some async. Give yourself a fair amount of time to read this and find small projects to do along the way to reinforce your knowledge.
