In my learning of Haskell and all the associated mathematical stuff attached to it, one of the tougher conceptual cookies to crack has been the Applicative Functor.

Coming from a background of fairly functional Javascript, functor is a very easy sell - it’s `array.map`

. Easy. If there’s a thing in the box, do something to the thing, if there’s nothing in the box, don’t freak out about the lack of things or explode. Great!

```
increase :: Int -> Int
= i + 1
increase i
-- fmap increase [1,2,3] == [2,3,4]
```

These functions can even return lists of their own…

```
moreList :: Int -> [Int]
= [a -1, a, a + 1] moreList a
```

```
listOfLists :: [[Int]]
= fmap moreList [1,2,3]
listOfLists -- listOfLists = [[0,1,2], [1,2,3], [2,3,4]]
```

Trying to understand the actual point of an Applicative Functor, especially to my Javascript-addled mind, was much trickier. The first explanations I heard were something like:

#### “Oh, applicative? It’s for taking a function that in a box, and a value in a box, and then combining them to make a new value which is also in a box”

Now I am all up for putting values in boxes. Bloody love it. But functions? What are you playing at? Ridiculous talk.

Could it help us with our list changing exercise? Sort of…

```
minusOne :: Int -> Int
= i - 1
minusOne i
doNothing :: Int -> Int
= id
doNothing
plusOne :: Int -> Int
= i + 1
plusOne i
applicativeList :: [Int]
= [minusOne, doNothing, plusOne] <*> [1,2,3]
applicativeList -- applicativeList == [0,1,2,1,2,3,2,3,4]
```

OK, so instead of a list of lists, we have one list (and one new terrifyingly meaningless infix operator, `<*>`

, wonderful). Seems like a lot more work too, and we could probably just have used `concat`

on the result and saved ourselves a whole load of intellectual soup. Sure. I get it. Terrible example. I’ve let us both down. I’m sorry.

Let’s see if we can find a slightly more helpful example.

`data CalcFace a = CalcFace [String] a deriving (Eq, Show)`

This data type is for describing calculations. The `a`

contains the current total, and the `[String]`

is used to describe what is happening. We’ve deriving standard `Eq`

and `Show`

instances for it, plus making our own fairly basic `Functor`

instance that, as you might expected, maps the function `f`

over any `a`

inside the datatype and leaves everything else alone like a good functor should.

```
instance Functor CalcFace where
fmap f (CalcFace names a) = CalcFace names $ f a
```

We also have this function, which we can use to print out the answer with our working.

```
showCalculation :: (Show a) => CalcFace a -> String
CalcFace names a) =
showCalculation (concat parts ++ " equals " ++ show a where
= intersperse " " names parts
```

Let’s try it out.

```
one :: CalcFace Int
= CalcFace ["1"] 1
one
showCalculation one-- == "1 equals 1"
```

Seems very reasonable.

Let’s try some mapping.

```
two :: CalcFace Int
= fmap (+1) one
two
showCalculation two-- == "1 equals 2"
```

Not so good. The answer is correct as we ran a `+1`

function over the `1`

to get `2`

, however we were unable to add anything to our log and thus the string output makes no sense. Perhaps `Functor`

is not powerful enough for our task.

Let’s give Applicative a go. Here’s one of those functions in a box we were talking about. This time we can also include a description of what the function does.

```
addOne :: CalcFace (Int -> Int)
= CalcFace ["add 1"] (+1) addOne
```

We’ll need an `Applicative`

instance for our datatype too. What does that look like?

`Prelude> :i Applicative`

```
class Functor f => Applicative (f :: * -> *) where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
:: (a -> b -> c) -> f a -> f b -> f c
GHC.Base.liftA2 (*>) :: f a -> f b -> f b
(<*) :: f a -> f b -> f a
{-# MINIMAL pure, ((<*>) | liftA2) #-}
```

There’s some pretty interesting jumping off points in there (such as the whole concept of `lifting`

, but we’ll come back to that), but fortunately we only need to implement two functions for this typeclass.

`pure`

- which takes an`a`

value and returns a sort of default value for that datatype. This is used internally in constructing new values.`<*>`

(called`apply`

IRL) - this takes one wrapped function and one wrapped value and combines them.

Confused? Me too! Let’s give it a pop.

```
instance Applicative CalcFace where
pure a = CalcFace [] a
CalcFace operation f) <*> (CalcFace value a) =
(CalcFace newNames (f a) where
= value <> operation newNames
```

OK. So `pure`

is reasonably straightforward - it just makes the most basic `CalcFace`

imaginable and puts whatever `a`

we pass inside it. The other function is a bit trickier though. Basically we are taking the function `f`

and applying to `a`

, but also taking the `[String]`

called `operation`

and plopping it on the end of the `[String]`

named `value`

.

Seems weird? Sure. Let’s see it in action though.

```
oneAddOne :: CalcFace Int
= addOne <*> one
oneAddOne
-- showCalculation oneAddOne == "1 add 1 equals 2"
```

Nice!

```
oneAddOneAddOne :: CalcFace Int
= addOne <*> oneAddOne
oneAddOneAddOne
-- showCalculation oneAddOneAddOne == "1 add 1 add 1 equals 3"
```

Great stuff. The key here is that not only have we acted upon the values, the way that `functor`

did, but we have also done something to the structure of the datatype too (in this case, adding to the list of operations). This seems trivial when the operators are just basic mathematics, but if the functions we are running are multiple database operations and calls to other servers, then you’ve got yourself the start of tidy little pure functional logging solution there, son.

Anyway. This barely scratches the surface, but hopefully gives you the start of an intuition for these things. Applicative does lots of things. Go find them!

Make sense? If not, why not get in touch?

Further reading: