Rust's lifetimes are a bit annoying, its async IO story is woeful, but it does allow safe mutation.
Haskell's more mature, IO is great, and it looks like cabal-hell may be ending, but it is a garbage-collected language.
Speaking of the garbage collector, it was the biggest productivity boost that software developers ever experienced and no matter how many tricks the Rust compiler pulls, the hit on productivity is real. And in terms of the "if it compiles, it runs" feeling, that comes with having an advanced type system. Rust pulls some really nice tricks, but cannot match Haskell. And again, the lack of a GC means the compiler's budget is spent on ensuring that the code is memory-safe, with other things having much lower priority.
I'm not convinced that's true. Rust is even stricter than Haskell in many respects (first example that comes to mind is incomplete pattern matches, which is a compiler error in rust) and strictness also avoids some run-time errors. I've managed to produce infinite loops in Haskell by accidentally defining recursive values more than once.
--hello.hs
f mx = case mx of
Just x -> x
--Nothing -> "NA"
main = do
let v = Just "5"
putStrLn $ f v
ghc -W hello.hs
[1 of 1] Compiling Main ( hello.hs, hello.o )
hello.hs:1:8: Warning:
Pattern match(es) are non-exhaustive
In a case alternative: Patterns not matched: Nothing(That being said, I think 'woeful' is a pretty strong word to describe the situation. Sure, Haskell is nicer in that regard, but most other languages aren't.)