Once you drink the koolaide it makes a lot of sense. Coming from a high level language like JS it has been hard to relearn things around memory management that really doesn't exist in JS, at least not generally. I used to hate strict type systems, but I've come to really enjoy them especially when it comes to the editing experience. Rust's compiler is fantastic and makes writing Rust code so much better, it actually gives you hints and points out why there are issues and where those issues are. I hope other languages learn from that and make the editing experience that much better.
Probably my favorite thing about Rust is the compiler, and the error messages it gives. The joke is that if your program compiles in Rust then, barring any logical errors, it probably works. Success may be inversely proportional to how many times you invoke the use of 'unsafe', but so far for my adventures in the language the adage has proven true.
I think Rust purely as a programming language and in terms of its feature set proves that compiled languages and their tooling can just be so much fucking better than C++ is it's not even funny. Compiled programs can be scripty (honestly, C++11/14 by themselves proved this), but it can also be a distinctly 'high level' experience through the lens of zero-cost abstractions and careful considering of design. Like almost anyone who comes from 'other' compiled languages, I've mixed feelings about Rust's take on memory management, ownership / lifetime, etc (there is something slightly backwards about making a language like Rust that operates at such a high level but is designed for programmers who know what they're doing!). "Fighting" the borrow-checker may be a meme at this point, but it is an important thing to pay attention to for this next point I'll make.
I think Rust is the first language I've used that is almost adamant that you understand 'other' programming languages *first*. It's like, a 'sequel' to a compiled language; you need to understand all the problems it is trying to solve on a relatively deep level (The list goes on, but memory leaks, double frees, seg faults / clobbered pointers, invalidated memory due to moves, ownership issues, lifetime issues, concurrency issues...) to actually understand *why* it's built the way it is. It is for this reason that I think Rust will have a fairly hard time in gaining traction widely; I don't know if it can reasonably be a 'first language' for people. Something as simple as its borrowing rule regarding mutability is understood through the lens of people who have been programming for a while and know why that exists.
All that being said, the old meme or whatever of compiled languages being old smelly socks that don't allow you to write high level elegant *and* performant code simultaneously is poppycock, and Cargo is as close as a compiled language has ever seen to an NPM like tool. Rust is, so far, a huge collection of evidences that things can be better, and that's true whichever side you fall on as regards Rust's opinions.