Why should Applicative be a superclass of Monad?

by

Well, I’m not terribly satisfied with the answers given so far, but I think the comments attached to them are a bit more compelling. So I’ll summarize here:

I think there’s only one sensible Functor instance that follows from Applicative:

fmap f fa = pure f <*> fa

Assuming that’s unique, it makes sense that Functor should be a superclass of Applicative, with that law. Likewise, I think there’s only one sensible Functor instance that follows from Monad:

fmap f fa = fa >>= return . f

So again, it makes sense that Functor should be a superclass of Monad. The objection I had (and, really, still have) is that there are two sensible Applicative instances that follow from Monad and, in some specific instances, even more that are lawful; so why mandate one?

pigworker (first author on the original Applicative paper) writes:

“Of course it doesn’t follow. It’s a choice.”

(on twitter): “do-notation is unjust punishment for working in a monad; we deserve applicative notation”

duplode similarly writes:

“… it is fair to say that pure === return and (<*>) === ap aren’t laws in the strong sense that e.g. the monad laws are so …”

“On the LeftA/RightA idea: there are comparable cases elsewhere in the standard libraries (e.g. Sum and Product in Data.Monoid). The problem of doing the same with Applicative is that the power-to-weight relation is too low to justify the extra precision/flexibility. The newtypes would make applicative style a lot less pleasant to use.”

So, I’m happy to see that choice stated explicitly, justified by the simple reasoning that it makes the most common cases easier.

More Related Contents:

  1. Good examples of Not a Functor/Functor/Applicative/Monad?
  2. Applicatives compose, monads don’t
  3. Difference between Monad and Applicative in Haskell
  4. How to interpret bind/>>= of the function instance?
  5. How to handle side effect with Applicative?
  6. Monads with Join() instead of Bind()
  7. Operating on a return from a Maybe that contains “Just”
  8. A Haskell function of type: IO String-> String
  9. Is monad bind (>>=) operator closer to function composition (chaining) or function application?
  10. IO happens out of order when using getLine and putStr
  11. What is indexed monad?
  12. Distinction between typeclasses MonadPlus, Alternative, and Monoid?
  13. Should do-notation be avoided in Haskell?
  14. Applicative functor evaluation is not clear to me
  15. Why does haskell’s bind function take a function from non-monadic to monadic
  16. Expressing do block using only monadic bind syntax
  17. Why do we need monads?
  18. Defining a new monad in haskell raises no instance for Applicative
  19. What are Alternative’s “some” and “many” useful for?
  20. What is a monad?
  21. Concrete example showing that monads are not closed under composition (with proof)?
  22. How to use (->) instances of Monad and confusion about (->)
  23. Why are side-effects modeled as monads in Haskell?
  24. Converting IO Int to Int
  25. Monoidal Functor is Applicative but where is the Monoid typeclass in the definition of Applicative?
  26. How to enumerate a recursive datatype in Haskell?
  27. Haskell – depth for each node in binary tree using Reader monad
  28. How to return a pure value from a impure method
  29. How does the ST monad work?
  30. functions as applicative functors (Haskell / LYAH)

Leave a Comment