Haskell - laziness can be exceedingly hard to reason about. Also it takes a lot of experience before you start designing your purity boundaries well.

Ocaml - figuring out the things surrounding the language (dependency management, concurrency, formatting, linting, etc)

I haven't learned/used them enough to appreciate higher-kinded types and the whole category theory monad thing. Individual usages make sense but each could be done differently without the generality.

One language that looks interesting is Clean[0]. It uses uniqueness types for mutations or other impure operations which kind of reminds me of software-transactional-memory or borrow checking.

[0] https://clean.cs.ru.nl/Clean

https://en.wikipedia.org/wiki/Clean_(programming_language)

Of those, I have only used Haskell (and F# which you didn't mention). While Haskell is a pure language, it's standard library is "unclean". Functions in Prelude have idiosyncratic names (words, unwords?) and it doesn't feel like they fit together.

But the real show-stopper for me is the five different string types Haskell has. I want to focus on algorithms and program design - not string conversions.

I also looked at Elm and liked it a lot but wondered why there was so much controversy around Sum/Union types and why they aren't 'just' added. If it was open-sourced and there was a fork that at least tried it, I'd be happier to use whichever one worked out for my use case.

I actually don’t like the way they manage data only through algebraic types passed around as parameters. That is one nice way to do things but I often find myself poorly reinventing relational stores or wishing for Datalog.

What do you dislike?

I’m thinking it could be the static typing but as I’ve done more and more work in static typed languages I like them a lot more than dynamically typed ones.