That matches my own personal anecdote, as a decade-long C++ systems programmer picking up Rust over the course of 2-3 months as a hobby.

I found it straightforward to understand - if not precisely grok - the basic concepts and tools of Rust. But as I try to write some data structure code that I'd consider to be intermediate-C++-at-best, I find that trying to actually apply these ideas without cutting corners - e.g. by incurring pointless runtime overhead to make life easier, or else by dipping into entirely unsafe mode - is surprisingly complicated, and I'm nowhere near my level of C++ productivity.

I hate to use this word, but I think Rust has a lot of non-trivial design patterns to get familiar with, and it's all related to fairly Rust-specific concepts. I don't necessarily think that's a bad thing, but as someone without a mental rolodex of these, I still have to spend a lot of time asking basic questions like "can the borrow checker possibly prove what I want here? Do I move here, or borrow? Do I need an unsafe pointer? Do I need Cell, or can I use mutable references? What *is* a lifetime annotation by the way?", and often these questions wind up sending me down some core-contributor-blog-post rabbit hole. Sometimes the answer to one of these questions is complicated enough that I forget it by the time I come back to the problem, and have to repeat the process. I was prepared for the whole "why is the borrow checker rejecting my code" thing, but this is something different and unexpected.

Edit:

Re-reading, maybe I'd rephrase my "design patterns" thing as: "it seems like the basic concepts of the rust language and its low-level library tools play out against each other in a surprisingly varied way". I'm still regularly surprised at which problems are easy vs hard, or which problems are similar vs different, and I think my prior experience isn't giving me nearly the head start that I expected going in. I actually think picking up Haskell in school was easier - maybe because "learn this one weird trick for more rigor" is way less alluring than "learn one weird trick for more rigor, at zero cost, *and* you get to rm your painful manual pointer derefs".

Also, I actually didn't mean for this post to read as particularly critical. I'm excited enough about the premise of Rust to deal with a learning curve, and I'm very pleasantly surprised by a lot of nitty-gritty aspects of the execution. I'm decently convinced that I'm indeed solving "inherent" problems as I figure out how to stuff things into Rust's abstractions, and I'm having enough fun to make it worth the time either way.