I came to this post by way of better understanding the inference of the infamous quote from Mac Lane's *Category Theory For the Working Mathematician*.

In describing what something is, it's often equally useful to describe what it's not.

The fact that Mac Lane uses the description to describe a Monad, one might imply that it describes something unique to monads. Bear with me. To develop a broader understanding of the statement, I believe it needs to be made clear that he is *not* describing something that is unique to monads; the statement equally describes Applicative and Arrows among others. For the same reason we can have two monoids on Int (Sum and Product), we can have several monoids on X in the category of endofunctors. But there is even more to the similarities.

Both Monad and Applicative meet the criteria:

The statement uses "Category of..." This defines the scope of the statement. As an example, the Functor Category describes the scope of `f * -> g *`

, i.e., `Any functor -> Any functor`

, e.g., `Tree * -> List *`

or `Tree * -> Tree *`

.

What a Categorical statement does not specify describes where *anything and everything is permitted*.

In this case, inside the functors, `* -> *`

aka `a -> b`

is not specified which means `Anything -> Anything including Anything else`

. As my imagination jumps to Int -> String, it also includes `Integer -> Maybe Int`

, or even `Maybe Double -> Either String Int`

where `a :: Maybe Double; b :: Either String Int`

.

So the statement comes together as follows:

- functor scope
`:: f a -> g b`

(i.e., any parameterized type to any parameterized type)
- endo + functor
`:: f a -> f b`

(i.e., any one parameterized type to the same parameterized type) ... said differently,
- a monoid in the category of endofunctor

So, where is the power of this construct? To appreciate the full dynamics, I needed to see that the typical drawings of a monoid (single object with what looks like an identity arrow, `:: single object -> single object`

), fails to illustrate that I'm permitted to use an arrow parameterized with *any number* of monoid values, from the *one* type object permitted in Monoid. The endo, ~ identity arrow definition of equivalence *ignores* the functor's *type value* and both the type and value of the most inner, "payload" layer. Thus, equivalence returns `true`

in any situation where the functorial types match (e.g., `Nothing -> Just * -> Nothing`

is equivalent to `Just * -> Just * -> Just *`

because they are both `Maybe -> Maybe -> Maybe`

).

Sidebar: ~ outside is conceptual, but is the left most symbol in `f a`

. It also describes what "Haskell" reads-in first (big picture); so Type is "outside" in relation to a Type Value. The relationship between layers (a chain of references) in programming is not easy to relate in Category. The Category of Set is used to describe Types (Int, Strings, Maybe Int etc.) which includes the Category of Functor (parameterized Types). The reference chain: Functor Type, Functor values (elements of that Functor's set, e.g., Nothing, Just), and in turn, everything else each functor value points to. In Category the relationship is described differently, e.g., `return :: a -> m a`

is considered a natural transformation from one Functor to another Functor, different from anything mentioned thus far.

Back to the main thread, all in all, for any defined tensor product and a neutral value, the statement ends up describing an amazingly powerful computational construct born from its paradoxical structure:

- on the outside it appears as a single object (e.g.,
`:: List`

); static
- but inside, permits a lot of dynamics
- any number of values of the same type (e.g., Empty | ~NonEmpty) as fodder to functions of any arity. The tensor product will reduce any number of inputs to a single value... for the external layer (~
`fold`

that says nothing about the payload)
- infinite range of
*both* the type and values for the inner most layer

In Haskell, clarifying the applicability of the statement is important. The power and versatility of this construct, has absolutely nothing to do with a monad *per se*. In other words, the construct does not rely on what makes a monad unique.

When trying to figure out whether to build code with a shared context to support computations that depend on each other, versus computations that can be run in parallel, this infamous statement, with as much as it describes, is not a contrast between the choice of Applicative, Arrows and Monads, but rather is a description of how much they are the same. For the decision at hand, the statement is moot.

This is often misunderstood. The statement goes on to describe `join :: m (m a) -> m a`

as the tensor product for the monoidal endofunctor. However, it does not articulate how, in the context of this statement, `(<*>)`

could also have also been chosen. It truly is a an example of six/half dozen. The logic for combining values are exactly alike; same input generates the same output from each (unlike the Sum and Product monoids for Int because they generate different results when combining Ints).

So, to recap: A monoid in the category of endofunctors describes:

```
~t :: m * -> m * -> m *
and a neutral value for m *
```

`(<*>)`

and `(>>=)`

both provide simultaneous access to the two `m`

values in order to compute the the single return value. The logic used to compute the return value is exactly the same. If it were not for the different shapes of the functions they parameterize (`f :: a -> b`

versus `k :: a -> m b`

) and the position of the parameter with the same return type of the computation (i.e., `a -> b -> b`

versus `b -> a -> b`

for each respectively), I suspect we could have parameterized the monoidal logic, the tensor product, for reuse in both definitions. As an exercise to make the point, try and implement `~t`

, and you end up with `(<*>)`

and `(>>=)`

depending on how you decide to define it `forall a b`

.

If my last point is at minimum conceptually true, it then explains the precise, and only computational difference between Applicative and Monad: the functions they parameterize. In other words, the difference is *external* to the implementation of these type classes.

In conclusion, in my own experience, Mac Lane's infamous quote provided a great "goto" meme, a guidepost for me to reference while navigating my way through Category to better understand the idioms used in Haskell. It succeeds at capturing the scope of a powerful computing capacity made wonderfully accessible in Haskell.

However, there is irony in how I first misunderstood the statement's applicability outside of the monad, and what I hope conveyed here. Everything that it describes turns out to be what is similar between Applicative and Monads (and Arrows among others). What it doesn't say is precisely the small but useful distinction between them.

- E

4more comments