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?
I think it's just that - the type system gives you so much, most hackers see a text editor with minimal type checking as good enough. Also IDEs tend to be commercial and I don't think any of the big companies see Haskellers as a good chunk of change. There's also quite a stigma many developers carry around regarding Haskell, though I don't understand that.
I don't think there's stigma around Haskell, aside from maybe complexity. I think there often is around Haskell programmers; there's a rep for jerkishness. (Both are commonly attributed to Scala as well, though I think, as a Scala person, the rep for jerkishness is much more earned in Scala-land.)
Scala is another one of those languages whose type information should enable a really good advanced experience, but the IDEs are struggling with respect to their peers (heroic efforts from jet brains and type safe not with standing). As parent said, many communities really don't appreciate or understand IDEs, and so what gets done reflects that.
F# has pretty good IDE support, and type providers are really nice as code completion extensions. C++ has excellent IDE support in visual studio, note I'm including the debugger here also, as that is part of the experience!
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).
There is nothing wrong with Haskell. It's just that writing an IDE is a lot of work and nobody bothered to invest that work so far. Haskell for Mac changes that. (I'm biased — I wrote it.)
It definitely provides some optimism with what is possible in Haskell, nice! I think it might be more of a community thing, many Haskell researchers I know don't have a desire for IDEs (so they don't write or use them as much), but I would also chalk some of it up to the language design and evolution not being very accommodating to the goal.
I'm guessing it works by refreshing the world right now, correct?
This sort of assumes that the objective of a language should be to create "an awesome IDE experience", while there's a good chunk of people who think having to have an IDE is simply a flaw in a language.
Coming from the other side, it seems like "because you should be able to do it manually" seems like a poor reason to not provide the option to have things automated.
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)?
So you mean, Haskell has a bunch of people who prefer to use the force rather than their targeting computers? So Haskell's language design obviates the need for good code completion or pervasive display of type inference results?
Also, as the joke goes, well typed programs can't go wrong in Haskell because the debugger just isn't that great.
Most serious Haskell users are most likely using a REPL and when doing this it's trivial to get and think about type information even while checking other stuff. It's also obviously part of the thought process while developing anyway, so I don't see the same value in this as you do. There's a cost to having a full IDE anyway and it's more sensible to get the features you do want (auto-completion, etc.) from plugins and then not using a IDE.
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:
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.