Every time somebody wants to show the difference between Applicative and Monad, they always pick ZipList, which is an Applicative but not a Monad.

I recently found yet another example which is less common.

## First’

Consider the following type:

``````newtype First' a b = First' (Maybe a)
``````

It is bivariant (both covariant and contravariant) in its tail argument `b`. Compiler sees this clearly:

``````{-# LANGUAGE DeriveFunctor #-}
newtype First' a b = First' (Maybe a)
deriving (Functor)
``````

I leave writing non-derived Functor instance to you as an excercise.

Please note that this functor ignores its argument completely, unlike pure Maybe.

The name First’ isn’t a coincidence. We’re going to use semantics of Data.Monoid.First here. Namely, First allows to mappend two Maybe values without descending into them:

``````λ> Nothing <> Just 'A'

<interactive>:
No instance for (Monoid Char) arising from a use of ‘<>’
...
``````
``````λ> First Nothing <> First (Just 'A')
First {getFirst = Just 'A'}
``````

## Monoid

Let’s write Monoid for our First’ with the same semantics:

``````instance Monoid (First' a b) where
mempty = First' Nothing
x@(First' (Just _)) `mappend` _ = x
_ `mappend` y = y
``````

Let’s try it in repl:

``````λ> First' Nothing <> First' (Just 'A')
First' (Just 'A')
``````

It works!

## Applicative

Let’s go next level. We’re going to write Applicative instance with this semantics. We also can reuse monoid instance.

``````instance Applicative (First' a) where
pure _ = First' Nothing
First' x <*> First' y = First' x <> First' y
``````

Check:

``````λ> First' Nothing <*> First' (Just 'A')
First' (Just 'A')
λ> First' Nothing *> First' (Just 'A')
First' (Just 'A')
``````

## Reverse Maybe

Why this is a reverse Maybe?

Maybe semantics may be expressed as:

• Nothing -> failure, stop
• Just x -> continue with x
``````λ> Nothing *> Just 1
Nothing
λ> Just 1 *> Just 2
Just 2
``````

First’ semantics is:

• Nothing -> continue
• Just x -> result is x, stop
``````λ> First' Nothing *> First' (Just 2)
First' (Just 2)
λ> First' (Just 1) *> First' (Just 2)
First' (Just 1)
``````

First’ doesn’t seem to be a Monad though. But I’m too lazy to prove it. If you can provide such a proof, please let me take a look at it.

## Const

Vladislav Zavialov noted that First’ is merely

``````type First' a b = Const (First a) b
``````

where First is from Data.Monoid.

Indeed,

``````λ> Const (First Nothing) *> Const (First (Just 2))
Const (First {getFirst = Just 2})
λ> Const (First (Just 1)) *> Const (First (Just 2))
Const (First {getFirst = Just 1})
``````

And Const is yet another interesting Applicative-not-Monad example.