The language thay you are already using! You need to understand FP, not a new language. Definitely read "Grokking simplicity" by Eric Normand.

But if you want to learn a new language more suited for FP, I would hardly recommend either guile scheme, racket, or clojure (all are lisps and you can use and build real word things with them forever). Haskell is also great but it's much harder than lisps.

You can do oop or fp with lisps, there is basically no syntax, you can get started and actually focusing on doing FP in a month. (Som say you can learn the language itself in a week, which you can but if you are really dedicating time to it).

I think Haskell would be a good choice. It's mature, used for real things (amongst a particular crowd, at least) and it's emphatic about being purely functional. Even when it is forced to enable other styles like imperative, it's done in a way that's syntactic sugar for a pure version (do notation being a great example of this, it's really just a chain of lambdas). You can do functional style programming in a lot of languages now, but they'll also let you mix and match other styles, which can make it easy to "cheat." Haskell will teach you functional programming and that's it.

Also, since it sounds like you're familiar with Rust, it uses a lot of ideas from Haskell. Rust enums are a clone of Haskell's algebraic data types, patterns are almost exactly the same, traits are typeclasses right down to the fact that the compiler can derive some common ones automatically, Rust strongly encourages immutability while Haskell basically requires it, and in both languages you're only allowed to break the rules if you start using things with the word unsafe in them. My experience learning Rust was "oh, C and Haskell had a baby named Rust, cool!" The big difference is that in Rust, you're programming from inside a C-style computer with RAM, while in Haskell you're programming in a mathematical void and the computer is tidily packed away in a box labeled IO.

A fun guide for learning Haskell is here: https://learnyouahaskell.github.io/

For a newbie probably something like Scheme (which is just a particular flavor of LISP) although I wouldn't call it a good language.

Here's the thing with purely functional languages that don't allow in place mutation (most of them, or only under special circumstances like Haskell's ST Monad), they force you into learning functions that typically don't exist in other languages like foldl and force you to think about approaching problems in a different way. This will make you a better programmer even when working on other languages, but it's very much something you have to learn and like all learning it will take time and effort.

I'm actually tempted to say Haskell is the best option because it actually is a really good language but it's not so much a learning curve as it is a learning grand canyon. It has an amazingly powerful type system (very similar to Rusts) and uses it very well, but it's also very unintuitive because it's deeply rooted in academia and uses names for things taken from set theory and mathematics (terms like endofunctor, profunctor, affine space, and of course the famous Monad). If you're finding Rust a struggle Haskell would be 10 times worse for many of the same reasons.

Another maybe good option that I can't definitively recommend would be OCaml. I've heard really good things about it and what I've seen of it looked good, but I haven't personally used it beyond maybe a little reading and a hello world type thing so I'm unsure what kind of pitfalls a newbie might run into.

The primary reason I'd recommend Scheme is because it's in many ways a very primitive language. Its type system is very simple and it really doesn't have a lot going on other than being purely functional. That is also its biggest downside with its second biggest problem being a rather annoying syntax (be prepared to spend a lot of time counting parens to make sure you're closing every pair and working in the scope you think you are).