By "combinator" do you mean combinator as in the combinator pattern?
I have no idea what value your comment brings us except a way for people who already agree with you to give you upvotes, and what's the point in that?
This drive-by-question style makes it hard for me to know what your real point is. Are you saying that an assignment does the same thing as a monad? OK. That it is a monad? I doubt it; assignment doesn't have the right operators (you might argue that it does, but you'd have to really stretch it.) That it's just as simple and easy to understand as a monad? I call BS.
> I have no idea what value your comment brings us except a way for people who already agree with you to give you upvotes, and what's the point in that?
That kind of rhetoric is against the site guidelines.
Using (something similar to) a monad (Javascript promises do not form a monad) successfully is different than using the monad abstraction successfully.
> and they are huge fans of do-notation in the from of async/await.
Async / await is not monadic do-notation. Arguably, it has a somewhat similar relationship to the underlying promise abstraction that do-notation had to the monad abstraction, but they aren't the same thing.
> Imperative programmers do not seem to have an issue with the idea of assignment, why are monads problematic
Why are the two halves of this sentence connected to each other since they have no relationship other than the proximity they've been (bizarrely) placed in.
function bindPromise(p, f) { return p.then(f); } function returnPromise(a) { return new Promise.resolve(a); }
Proof of the laws left as an exercise to the reader :).
But yes, you are correct that promises do quite a bit more than only being a monad, for example because of how they treat errors.
EDIT: I concede, I am wrong! https://buzzdecafe.github.io/2018/04/10/no-promises-are-not-...
I also think there's nothing precluding some Monads to be good ideas and others to be bad ideas.
Similarly, the delivery could have a big impact. So it might be the theory of it is good, but a better delivery in terms of programming UX needs to be used. So maybe the dot notation somehow delivers better then the do notation.
Having said all that, I like Haskell, better than JS.
return x; return x -> return yield*x
return yield x; yield x -> yield*x
(at least, I think it is; I may have made a mistake)And there's nothing wrong with wanting purity and immutability that badly. And there's nothing wrong with not.
I suspect that FP fits the way some people think, and imperative fits how some other people think. And I don't think there's anything wrong with that. I'm a fan of picking the tool that is best suited to the job, and the person who is going to be using the tool is one of the biggest components of "suited". I might even say, of all the languages that suit you, pick the one that best suits the task.
Their use is (seems?) straightforward - I have a context that can hand me a value, take values from me, or thread a state.
Also, they're "just" thin wrappers around common types. `Reader r` is `r -> a`; `Writer w` is `(a, w)`; `State s` is `s -> (a, s)`.
I'm interested whether you can unpack a bit where the difficulty seems to lie. Backgrounds differ and what's simple for one may be complex for another, without any judgement around overall capability.
That said, I think there are some legitimate reasons for the impression.
For one, Haskell (not uniquely) lacks the distinction between statement and expression found in many languages. This means that you have a freer hand about "where you cut" when breaking up your problem. In a way this is good - the optimal choice may be better when you have more options. But it also means a lack of consistency and more to learn about how to do it well.
Haskell's syntax is unusual. Everything is a harder to follow when you still need to work to parse things. There is a frustrating space between knowing the syntax well enough to want to learn other things and being sufficiently fluent that the new concepts are the only hard thing.
There are habits to reading Haskell code that differ from those involved in reading other languages - a big one being knowing how the types flow through an expression and how to spot where they're pinned down in various contexts.