Stuff like this makes me wonder why: a) Haskell isn't used more widely b) isn't taught in school more. It seems it's a language that's intellectually stimulating and shows how much a good language design can help with programing work.
When a newbie starts using Haskell, they are immediately put off by the fact that the messages are...esoteric to say the least; weird things of `result a0, expected [b0]`, can be offputting, and make things like F# a much more attractive option.
Also, I feel like, until Intero, editor integration with ghcmod was incredibly difficult to set up, and fairly easy to break, to a point where I eventually uninstalled it.
Cabal, while certainly interesting, would end up in weird scenarios where dependencies wouldn't resolve correctly, resulting in "cabal hell".
Stack has greatly improved on all of these points, and hopefully Haskell catches on a bit more, because despite my criticisms, I do think it's a fantastic language and platform.
- HIE (Haskell IDE Engine) finally got some steam behind it, and has been chugging along for some time now, being very usable and targeting LSP!
- Intero (as you mention)
- ghcid is a nice lightweight alternative
I personally feel stack + hie is a very good setup, and can be used in VSCode, Atom, Neovim and emacs via LSP clients.
Error messages are slowly improving. GHC 8.2 got nice highlighting of the location of the error and some colouring, bringing it just a little further. I personally like how nice Elm is, but then again it has the advantage of a much simpler type systems, which significantly simplifies error handling.
I definitely think Stack is excellent, and greatly reduces the cost-of-entry for new devs, and it's only getting better, so Haskell is far from hopeless.
Furthermore libraries vary immensely in quality and for beginners it is hard to pick the right one for your job. Unfortunately most of them are also documented quite ... sparse.
It is also non-trivial to get a good web-stack up and running and there are many competing solutions using different architectures and with a different stance on type-safety. Their poor performance in benchmarks like https://www.techempower.com/benchmarks/ does not help either.
I don't want to dismiss Haskell and love the idea of FP especially using advanced type systems to get rid of possible bugs before runtime, but using it for specific tasks is not always straight-forward compared to more established languages.
I like how succint haskell/ML syntax is. But I prefer practical work and controll so I personally plan to learn/use either F# or Reason/Ocaml.