What is the difference between pure and mempty in Haskell?

Question

In shool, I was task to write a function which appends Numbers to the left side of a list, if they are even. The type-signature was given as:

appendIfEven :: (Applicative f, Monoid (f a), Integral a) => a -> f a -> f a

My answer was the following piece of code

appendIfEven :: (Applicative f, Monoid (f a), Integral a) => a -> f a -> f a
appendIfEven x ms = if x `mod` 2 == 0 then mempty x `mappend` ms else ms

Haskell can compile my code, but it does not work properly. After some experimenting, I switched mempty to pure :

appendIfEven :: (Applicative f, Monoid (f a), Integral a) => a -> f a -> f a
appendIfEven x ms = if x `mod` 2 == 0 then pure x `mappend` ms else ms

Which works fin. But why ? shouldn't pure == mempty ? (In this context) It seems to be not important for my Tutor. However I would really like to understand a bit more about Haskell and where I am wrong ....

Answer 1

Consider applying this to lists.

mempty == []

pure 5 = [5]

Those don't look very similar to me. In particular, mempty x ought to be ill-typed.

Basically mempty gives you an empty thing, whereas pure x gives you a thing with an x in it.

Answer 2

You inadvertently used an unexpected monoid, which incidentally made your code compile.

When you wrote mempty x `mappend` ms, the ms value has type f a, which is a monoid. This forces mempty x to have the same type, since mappend requires two arguments of the same type. Hence we must have

mempty x :: f a

which implies, since x :: a,

mempty :: a -> f a

Weird, right?

Well, it happens that there is an instance in the libraries

instance Monoid t => Monoid (u -> t) where
   mempty = \_ -> mempty
   ...

which you inadvertently used passing x to mempty, since t can be f a, and u can be a in the instance above. Haskell resolved the monoid constraint so to use this instance.

This also means that

mempty x `mappend` ms

is the same as

(\_ -> mempty) x `mappend` ms  -- this is the mempty for (f a), instead!

which is the same as

mempty `mappend` ms   -- this is the mempty for (f a), instead!

which is the same as

ms

Hence, your code completely ignores the x argument.

By contrast pure x does depend on x, in the general case, so the end result can be very different.