Monoidal Functor is Applicative but where is the Monoid typeclass in the definition of Applicative?

by

The monoid that’s referred to with “monoidal functor” is not a Monoid monoid, i.e. a value-level monoid. It’s a type-level monoid instead. Namely, the boring product monoid

type Mempty = ()
type a <> b = (a,b)

(You may notice that this is not strictly speaking a monoid; it’s only if you consider ((a,b),c) and (a,(b,c)) as the same type. They are sure enough isomorphic.)

To see what this has to do with Applicative, resp. monoidal functors, we need to write the class in other terms.

class Functor f => Monoidal f where
  pureUnit :: f Mempty
  fzip :: f a -> f b -> f (a<>b)

-- an even more “general nonsense”, equivalent formulation is
-- upure :: Mempty -> f Mempty
-- fzipt :: (f a<>f b) -> f (a<>b)
-- i.e. the functor maps a monoid to a monoid (in this case the same monoid).
-- That's really the mathematical idea behind this all.

IOW

class Functor f => Monoidal f where
  pureUnit :: f ()
  fzip :: f a -> f b -> f (a,b)

It’s a simple exercise to define a generic instance of the standard Applicative class in terms of Monoidal, vice versa.

Regarding ("ab",(+1)) <*> ("cd", 5): that doesn’t have much to do with Applicative in general, but only with the writer applicative specifically. The instance is

instance Monoid a => Monoidal ((,) a) where
  pureUnit = (mempty, ())
  fzip (p,a) (q,b) = (p<>q, (a,b))

More Related Contents:

  1. Good examples of Not a Functor/Functor/Applicative/Monad?
  2. Applicatives compose, monads don’t
  3. Distinction between typeclasses MonadPlus, Alternative, and Monoid?
  4. Applicative functor evaluation is not clear to me
  5. Difference between Monad and Applicative in Haskell
  6. What are Alternative’s “some” and “many” useful for?
  7. How to interpret bind/>>= of the function instance?
  8. Why should Applicative be a superclass of Monad?
  9. How to handle side effect with Applicative?
  10. functions as applicative functors (Haskell / LYAH)
  11. `String’ is applied to too many type arguments
  12. How do I define Lisp’s apply in Haskell?
  13. Is there a Haskell idiom for updating a nested data structure?
  14. What’s so bad about Lazy I/O?
  15. Why do 3 and x (which was assigned 3) have different inferred types in Haskell? [duplicate]
  16. How do I use fix, and how does it work?
  17. List of different types?
  18. What is Levity polymorphism
  19. How to infer the type of an expression manually
  20. Understanding the Haskell as-pattern
  21. Haskell: How to create most generic function possible that applies a function to tuple items
  22. Concrete example showing that monads are not closed under composition (with proof)?
  23. Why can a Num act like a Fractional?
  24. Composing function composition: How does (.).(.) work?
  25. Why doesn’t TypeSynonymInstances allow partially applied type synonyms to be used in instance heads?
  26. How do I convert a list to a tuple in Haskell?
  27. Implement zip using foldr
  28. Why does OCaml sometimes require eta expansion?
  29. Explanation of “tying the knot”
  30. Return specific type within Haskell

Leave a Comment