All that static typing shoud lead to an awesome IDE experience. Given that this hasn't happened, I wonder if there isn't something wrong with Haskell's design that works against it?
Java, C# ... and both received probably hundred times more man-power than Scala IDEs.
What else?
My experience: All dynamic languages – probably not. C++? Hell no. F#? No. OCaml? No. Haskell? No.
Which language do you think of?
Then there is objective C, Swift, Kotlin, Dart, Typescript, some versions of smalltalk. Many of those languages were designed specifically for IDE use (dart and typescript definitely).
I'm guessing it works by refreshing the world right now, correct?
Also, as the joke goes, well typed programs can't go wrong in Haskell because the debugger just isn't that great.
Even if you want these things, there are better ways to go about this instead of making a whole gargantuan interface to get a couple of features.
I'm not usually one to tell people what they should be working on, but time could be spent on this instead:
https://github.com/haskell/haskell-mode/wiki
(See also this for how to get in-source error information and type checking, if needed:
The computer is more accurate and faster at determining the type of an expression than humans are. That seems like a big part of the value proposition of static languages. So why not let it tell you the type in the editor instead of having to stop what you are doing to compile it (which may require fiddling with the code to get a meaningful type error)?
The main problem is that there aren't good ways for Haskell analyzers to communicate with a Java/C++ UI in memory. So you get clunky+slow network/IPC APIs (or worse, communication via filesystem) for stuff that ought to be tiny in-process method calls.
And writing the whole UI in Haskell is...not Haskell's strength area.