Marvin can probably speak more on async/awaits but it's one of the problems of doing async in typed languages, since the async type-ness contaminates all the other types it touches, so from type T you suddenly need to work with Async<T>, which is where fancy-pants things like monads come in.
You could level this argument against something as simple as Option and Maybe, where Optional-ness also pollutes everything it touches. But Options are generally considered the right-thing in typed languages, and the supposed billion dollar mistake of the null value means that even Java programmers are encouraged to use Optionals. In modern Java code, you'll also see Optionals combined with chains of flatMaps, or as a Haskeller would call them, "binds".
The argument that it's important for a typed language to distinguish Optional<T> from T is the same one that says that Async<T> should be distinguished from T. You want the type system to distinguish an honest-to-gods integer from an asynchronous computation that may have a lot of I/O to do before returning an integer, may fail with an exception, or may block forever.
The issues come with how noisy all this ends up being, in terms of how many types you have to write down (in Java, it's a
lot), and how verbose the syntax is for combining asynchronous computations. F# got these issues sorted way early. It made sure the type system stayed close enough to Ocaml that you near enough have global type inference, so you don't have to splatter your code with type annotations, and it introduced computation expressions, a slightly more expressive "do-notation" inspired by Haskell. Ocaml did the same, introducing syntax preprocessors early for writing "do-notation" style async code, a variant of which has now become part of the official language syntax.
Java doesn't have either. I've written a fair bit of production asynchronous code using Java, and it makes my eyes bleed. There were basically only a couple of developers who were expected to read and write it.
The missing part of the monad story is the monad libraries, which none of these languages have, and which are still pretty much unique to Haskell. In Haskell, I can write functions that are generic over all monads, or even broad classes of monad, and then write more functions in terms of those which stay generic. It means that the same code in Haskell is even less noisy and has far less redundancy as common patterns get factored out and used over and over.
The massive difference this makes to coding style is why I don't really talk about monads in languages like F#, Java or Ocaml. I'm not going to call monads a real abstraction in a language unless I can, you know,
abstract over them.
