> What we need is an FP language that doesn't pretend that outside world doesn't exist. A pragmatical one.

yes, anything focusing on devs being actually productive has to be pragmatic. So, yeah, real world exists, IO needs to be "easy/simple", just like compiling should be fast, good error messages, etc. Lots of constraints, Go is nice because it is "good enough" at everything. So it's productive general programming language.

> This is why Erlang/Elixir or even C# or hell even Javascript/Typescript are better FPs for the vast majority of programmers (and beginner programmers, too) than Haskell.

Disagree here. Fully agree those and pretty much all popular languages are better than haskell for the very mast majority of devs including beginner on actually delivering something aka work.
I disagree that haskell is worse for somebody that never actually programmed to learn programming (which is fundamentally different than creating an working application or modifying one), specially at a CS college/university course, than any of the languages you listed.

"basic" Haskell is extremely simple. And it's syntax mirrors what you would typically use when are doing something with functions during your high school. Recursion is not harder than loops, the hard part is going from lots of familiarity with one to the other. I've seen people learning imperative first and functional first at different places, and I can tell you that the confusion first timers face getting to understand a loop is not smaller than recursion(again "x = x +1" hits hard against everything you see in school until programming, re-assigning is evil for teaching).

With recursion, haskell's enums/unions equivalent, and haskell's interface equivalent, you can get really far!
So you won't hit haskell issues while teaching because:
* problems/assignments can be self contained, you don't need to reach for libraries to make simple compiler for example, so you don't have the ivory tower of type category, all conversations about monads, someone else code using unfamiliar lingo/code
* due to good interpreter, IO can be teached last, and can always be and should be only a layer over the rest of the code, and once familiar with the rest, writing some outer functions using do notation to pass to your core isn't troublesome to understand.

F# and Ocaml are not as nice for that purpose, as polymorphism/generics is better teached with haskell, and the language is more consistent without objects.

Racket and some lisps are nice, but i would say that Type checking is important for teaching, due to the whole concept of change data from one thing to another, gets easier to explain, the compiler gives some help as well.

Teaching 1st timers (assuming college) with Haskell Drawbacks IMO are only:
* reaching for out of the class stuff, online discussions and public haskell libraries are hell due to academic mismatch.
with too much
* while type checking and compiler messages are a nice help teaching, they can also have the opposite effect with cryptic messages if for some reason there was some heavy polymorphic/generic code.

For a more general teaching, I'll add the drawback of not being able to do what the general crowd thinks of a "app" or "web app" etc, easily. JS just working on a browser is great, swift playgrounds are great, ruby has rails, etc.