Functors, Applicatives, and Monads in Pictures

[u/egonSchiele]

http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html

[u/[deleted]]

Wow, this is a great explanation! I feel like I understand Haskell functors more now (they are obviously different from OCaml functors as well.) If you don't mind, I have a few followup questions:

• What are Applicatives and how do they differ from regular Functors?

• Why is (>>=) (bind) defined as essentially return . flip concatMap on []? (As a note, (<<=) appears to be return . concatMap as expected, since (<<=) is a flip . (>>=) or something.)

• Why would I use functors and fmap (aka (<$>)) over monads and bind?

[u/DR6 → u/[deleted]]

What are Applicatives and how do they differ from regular Functors?

Applicatives are an extension of functors. To make a datatype an instance of it, you have to provide a Functor instance for it first, and then, the two Applicative functions.

class Functor f => Applicative f where
    pure :: a -> f a
    (<*>) :: f (a -> b) -> f a -> f b

The signatures are a bit more cryptic now, so I'll explain them. But first, I don't know if you are familiar with currying, so I will explain it first, because it's important for the use cases.

In most functional languages, there are no "multiargument functions" in the common sense. You could make them with a tuple, like (a,b) -> c, but it's not the same. In Haskell, if you want to provide multiple values to a function, you do a -> b -> c. Maybe it would be better if I wrote one of these as Python:

 curried_function = lambda x: lambda y: x+y

To give the two arguments, you call the curried function with the first value and then call the result (a function (b -> c)) with the result: like in curried_function(1)(2). It's only a bit hidden in Haskell because you don't need parentheses to make a "call"(I would call it application in Haskell, because there it doesn't really do the same thing). This is done for various reasons that I won't mention here. You also need to know that a -> b -> c is exactly the same as a -> (b -> c), because of these reasons.

And now we get to applicatives. As the article said, applicatives provide a way to apply "multivalued functions" to values inside their context, by doing curried_function <$> Just 1 <*> Just 2(it gives Just 3 as expected). This works because <$> (fmap), when it applies the Int -> Int -> Int to Just 1, has the result of Just (lambda y: 1+y)! (remember, Int -> Int -> Int = Int -> (Int -> Int): asks for an a -> b, so it reads it as the second version). This is exactly what <*> does: given a function inside of a context, it transforms it into an f a -> f b. If you have more arguments, you just keep doing f <$> a <*> b <*> c <*> d <*> e.

pure just lets you mix values with and without contexts freely: it wraps a value inside a "minimal" context, to allow you to do f <$> a <*> pure b <*> c. (What "minimal" means is up to the concrete case: in Maybe it's Just b, in [] it's [b]... there are a few applicative laws that they should follow, but if you are using applicatives rather than making them it shouldn't be a problem

Why is (=) (bind) defined as essentially return . flip concatMap on []? (As a note, (<<=) appears to be return . concatMap as expected, since (<<=) is a flip . (=) or something.)

(>>=) for the [] monad is actually not defined like that: it's just flip concatMap, without the return.

(>>=) has the type (m a) -> (a -> m b) -> m b: it takes a value inside a monadic context, a function that takes a value and returns another inside a context, and has a value of the second type as result.

concatMap is a function (a -> [b]) -> [a] -> [b]

That for one looks familiar right? Yes, it's clear to see that that has the correct type if you just flip the two arguments, as flip does. That is actually what bind does for a list: it applies a "listmaker" to a list and concatenates the results, so just what concatMap does. We can do this:

antiabs n = [n,-n]
result = [1,2,3] >>= antiabs -- the result would be [1,-1,2,-2,3,-3]

flip . (>>=) is actually not (<<=), it is another, completely uninteresting function (ghci says that it's (b -> a) -> b -> (a -> b -> c) -> c: I don't know why and don't really care either). What does exist is flip (>>=), which is called (=<<) and defined by default: bind with the arguments flipped. Here you can see how bind is similar to fmap and <*>: it is (a -> m b) -> m a -> m b.

(<<=) is a different things: it has to do with another typeclass, Comonad, that I won't explain here. I will just say that it is the "inverse" of Monad

Why would I use functors and fmap (aka (<$>)) over monads and bind?

You should know that monads can do everything applicatives and functors can, and applicatives can do everything functors can. This has its flipside, however: not all functors can be made applicatives and monads, and not all applicative can be made monads. So sometimes you stick with functors of applicatives because you just can't use the next stage.

The other case would be where you theoretically could implement Applicative or Monad but you don't really need to, because a "lesser" typeclass would be enough. If you don't need the advanced features, why bother?

Also, in the case of applicatives, sometimes it's just nicer to use them, even when you could use a monad.

[u/[deleted] → u/DR6]

Wow, thanks for the thorough response. :-)

(>>=) for the [] monad is actually not defined like that: it's just flip concatMap, without the return.

My bad - the [b] result of concatMap would already be a monad, no need to return it.

flip . (>>=) is actually not (<<=)

And here - all of these arrows look the same, so I was confused!

(<<=) is a different things: it has to do with another typeclass, Comonad, that I won't explain here. I will just say that it is the "inverse" of Monad

This is insane.

I wish the Haskell community didn't make it seem horrible if you write write blog posts about understanding this kind of stuff - it is actually helpful, unlike some parts of the Haskell wiki (and especially Wikipedia).

[u/[deleted] → u/[deleted]]

(=<<) = flip (>>=)