I observed and contributed to Rust programming language for four years now, and I have come to a conclusion: Rust's primary difficulty in adoption is mismatch of expected learning curve and actual learning curve. Actual learning curve itself is okay.
(Of course, there is general immaturity in tooling and ecosystem. Here I concentrate on conversion from trying Rust to getting basic Rust competency. Two important scenarios, 1. I am not trying Rust because I can't see how it would be useful to me right now, and 2. I finished learning Rust basics, but I still think it is not a good idea to do my real world project in Rust, are not discussed here.)
Going with a bit of caricature, consider Java, C++, Rust and "X programmer learns Y". Here "X programmer" excludes polyglot programmers, since they are minority. Since there are also too few Rust programmers to matter, there are four cases:
Case 1. Java programmers learn C++. People expect this to be hard, and it is actually hard.
Case 2. C++ programmers learn Java. People expect this to be easy, and it is actually easy.
Case 3. Java programmers learn Rust. People expect this to be hard, and it is actually hard.
Case 4. C++ programmers learn Rust. For some reason, people expect this to be easy, but it is actually hard. In my experience, it is equally hard for C++ programmers to learn Rust as for Java programmers to learn Rust. Mismatch in expectation causes frustration.
One theory I have is that Java programmers expect Rust to be hard because they think they don't know "memory management", and C++ programmers expect Rust to be easy because they think they know "memory management".
The problem is, C++ programmers know "C++ memory management", not "memory management". To learn Rust, you need to learn "Rust memory management". And knowing "C++ memory management" doesn't help you learning "Rust memory management", not as much as people expect. It helps a little, but if you expect, say, it to be as half as difficult as learning C++ for the first time, you'd be rudely surprised. In practice, people don't expect even half.
In other words, many people seem to have a linear model where Java is at one end, Rust is at the other end, and C++ is closer to Rust than Java. In reality, Rust is about equidistant from both C++ and Java.
The question is how to correct expectation. I really have no idea, but maybe explicitly talking about the problem will help.