Unlike monads, which came into programming straight from category theory, applicative functors have their origins in programming. McBride and Paterson introduced applicative functors as a programming pearl in their paper Applicative programming with effects. They also provided a categorical interpretation of applicatives in terms of *strong lax monoidal functors*. It’s been accepted that, just like “a monad is a monoid in the category of endofunctors,” so “an applicative is a strong lax monoidal functor.”

The so called “tensorial strength” seems to be important in categorical semantics, and in his seminal paper Notions of computation and monads, Moggi argued that effects should be described using *strong* monads. It makes sense, considering that a computation is done in a context, and you should be able to make the global context available under the monad. The fact that we don’t talk much about strong monads in Haskell is due to the fact that all functors in the category **Set**, which underlies the Haskell’s type system, have canonical strength. So why do we talk about strength when dealing with applicative functors? I have looked into this question and came to the conclusion that there is no fundamental reason, and that it’s okay to just say:

An applicative is a lax monoidal functor

In this post I’ll discuss different equivalent categorical definitions of the applicative functor. I’ll start with a lax closed functor, then move to a lax monoidal functor, and show the equivalence of the two definitions. Then I’ll introduce the calculus of ends and show that the third definition of the applicative functor as a monoid in a suitable functor category equipped with Day convolution is equivalent to the previous ones.

## Applicative as a Lax Closed Functor

The standard definition of the applicative functor in Haskell reads:

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

At first sight it doesn’t seem to involve a monoidal structure. It looks more like preserving function arrows (I added some redundant parentheses to suggest this interpretation).

Categorically, functors that “preserve arrows” are known as *closed* functors. Let’s look at a definition of a closed functor `f`

between two categories *C* and *D*. We have to assume that both categories are closed, meaning that they have internal hom-objects for every pair of objects. Internal hom-objects are also called function objects or exponentials. They are normally defined through the right adjoint to the product functor:

C(z × a, b) ≅ C(z, a => b)

To distinguish between sets of morphisms and function objects (they are the same thing in **Set**), I will temporarily use double arrows for function objects.

We can take a functor `f`

and act with it on the function object `a=>b`

in the category *C*. We get an object `f (a=>b)`

in D. Or we can map the two objects `a`

and `b`

from *C* to *D* and then construct the function object in *D*: `f a => f b`

.

We call a functor *closed* if the two results are isomorphic (I have subscripted the two arrows with the categories where they are defined):

f (a =>_{C}b) ≅ (f a =>_{D}f b)

and if the functor preserves the unit object:

i_{D}≅ f i_{C}

What’s the unit object? Normally, this is the unit with respect to the same product that was used to define the function object using the adjunction. I’m saying “normally,” because it’s possible to define a closed category without a product.

Note: The two arrows and the two `i`

s are defined with respect to two different products. The first isomorphism must be natural in both `a`

and `b`

. Also, to complete the picture, there are some diagrams that must commute.

The two isomorphisms that define a closed functor can be relaxed and replaced by unidirectional morphisms. The result is a *lax closed* functor:

f (a => b) -> (f a => f b) i -> f i

This looks almost like the definition of `Applicative`

, except for one problem: how can we recover the natural transformation we call `pure`

from a single morphism `i -> f i`

.

One way to do it is from the position of strength. An endofunctor `f`

has tensorial strength if there is a natural transformation:

st_{c a}:: c ⊗ f a -> f (c ⊗ a)

Think of `c`

as the context in which the computation `f a`

is performed. Strength means that we can use this external context inside the computation.

In the category **Set**, with the tensor product replaced by cartesian product, all functors have canonical strength. In Haskell, we would define it as:

st (c, fa) = fmap ((,) c) fa

The morphism in the definition of the lax closed functor translates to:

unit :: () -> f ()

Notice that, up to isomorphism, the unit type `()`

is the unit with respect to cartesian product. The relevant isomorphisms are:

λ_{a}:: ((), a) -> a ρ_{a}:: (a, ()) -> a

Here’s the derivation from Rivas and Jaskelioff’s Notions of Computation as Monoids:

a ≅ (a, ()) -- unit law, ρ^{-1}-> (a, f ()) -- lax unit -> f (a, ()) -- strength ≅ f a -- lifted unit law, f ρ

Strength is necessary if you’re starting with a lax closed (or monoidal — see the next section) endofunctor in an arbitrary closed (or monoidal) category and you want to derive `pure`

within that category — not after you restrict it to **Set**.

There is, however, an alternative derivation using the Yoneda lemma:

f () ≅ forall a. (() -> a) -> f a -- Yoneda ≅ forall a. a -> f a -- because: (() -> a) ≅ a

We recover the whole natural transformation from a single value. The advantage of this derivation is that it generalizes beyond endofunctors and it doesn’t require strength. As we’ll see later, it also ties nicely with the Day-convolution definition of applicative. The Yoneda lemma only works for **Set**-valued functors, but so does Day convolution (there are enriched versions of both Yoneda and Day convolution, but I’m not going to discuss them here).

We can define the categorical version of the Haskell’s applicative functor as a *lax closed functor* going from a closed category *C* to **Set**. It’s a functor equipped with a natural transformation:

f (a => b) -> (f a -> f b)

where `a=>b`

is the internal hom-object in `C`

(the second arrow is a function type in **Set**), and a function:

1 -> f i

where `1`

is the singleton set and `i`

is the unit object in `C`

.

The importance of a categorical definition is that it comes with additional identities or “axioms.” A lax closed functor must be compatible with the structure of both categories. I will not go into details here, because we are really only interested in closed categories that are monoidal, where these axioms are easier to express.

The definition of a lax closed functor is easily translated to Haskell:

class Functor f => Closed f where (<*>) :: f (a -> b) -> f a -> f b unit :: f ()

## Applicative as a Lax Monoidal Functor

Even though it’s possible to define a closed category without a monoidal structure, in practice we usually work with monoidal categories. This is reflected in the equivalent definition of the Haskell’s applicative functor as a lax monoidal functor. In Haskell, we would write:

class Functor f => Monoidal f where (>*<) :: (f a, f b) -> f (a, b) unit :: f ()

This definition is equivalent to our previous definition of a closed functor. That’s because, as we’ve seen, a function object in a monoidal category is defined in terms of a product. We can show the equivalence in a more general categorical setting.

This time let’s start with a symmetric closed monoidal category *C*, in which the function object is defined through the right adjoint to the tensor product:

C(z ⊗ a, b) ≅ C(z, a => b)

As usual, the tensor product is associative and unital — with the unit object `i`

— up to isomorphism. The symmetry is defined through natural isomorphism:

γ :: a ⊗ b -> b ⊗ a

A functor `f`

between two monoidal categories is *lax monoidal* if there exist: (1) a natural transformation

f a ⊗ f b -> f (a ⊗ b)

and (2) a morphism

i -> f i

Notice that the products and units on either side of the two mappings are from different categories.

A (lax-) monoidal functor must also preserve associativity and unit laws.

For instance a triple product

f a ⊗ (f b ⊗ f c)

may be rearranged using an associator α to give

(f a ⊗ f b) ⊗ f c

then converted to

f (a ⊗ b) ⊗ f c

and then to

f ((a ⊗ b) ⊗ c)

Or it could be first converted to

f a ⊗ f (b ⊗ c)

and then to

f (a ⊗ (b ⊗ c))

These two should be equivalent under the associator in *C*.

Similarly, `f a ⊗ i`

can be simplified to `f a`

using the right unitor ρ in *D*. Or it could be first converted to `f a ⊗ f i`

, then to `f (a ⊗ i)`

, and then to `f a`

, using the right unitor in *C*. The two paths should be equivalent. (Similarly for the left identity.)

We will now consider functors from *C* to **Set**, with **Set** equipped with the usual cartesian product, and the singleton set as unit. A *lax monoidal functor* is defined by: (1) a natural transformation:

(f a, f b) -> f (a ⊗ b)

and (2) a choice of an element of the set `f i`

(a function from 1 to `f i`

picks an element from that set).

We need the target category to be **Set** because we want to be able to use the Yoneda lemma to show equivalence with the standard definition of applicative. I’ll come back to this point later.

## The Equivalence

The definitions of a lax closed and a lax monoidal functors are equivalent when *C* is a closed symmetric monoidal category. The proof relies on the existence of the adjunction, in particular the unit and the counit of the adjunction:

η_{a}:: a -> (b => (a ⊗ b)) ε_{b}:: (a => b) ⊗ a -> b

For instance, let’s assume that `f`

is lax-closed. We want to construct the mapping

(f a, f b) -> f (a ⊗ b)

First, we apply the lifted pair (unit, identity), `(f η, f id)`

(f a -> f (b => a ⊗ b), f id)

to the left hand side. We get:

(f (b => a ⊗ b), f b)

Now we can use (the uncurried version of) the lax-closed morphism:

(f (b => x), f b) -> f x

to get:

f (a ⊗ b)

Conversely, assuming the lax-monoidal property we can show that the functor is lax-closed, that is to say, implement the following function:

(f (a => b), f a) -> f b

First we use the lax monoidal morphism on the left hand side:

f ((a => b) ⊗ a)

and then use the counit (a.k.a. the evaluation morphism) to get the desired result `f b`

There is yet another presentation of applicatives using Day convolution. But before we get there, we need a little refresher on calculus.

## Calculus of Ends

Ends and coends are very useful constructs generalizing limits and colimits. They are defined through universal constructions. They have a few fundamental properties that are used over and over in categorical calculations. I’ll just introduce the notation and a few important identities. We’ll be working in a symmetric monoidal category *C* with functors from *C* to **Set** and profunctors from *C ^{op}×C* to

**Set**. The end of a profunctor

`p`

is a set denoted by:∫_{a}p a a

The most important thing about ends is that a set of natural transformations between two functors `f`

and `g`

can be represented as an end:

[C, Set](f, g) = ∫_{a}C(f a, g a)

In Haskell, the end corresponds to universal quantification over a functor of mixed variance. For instance, the natural transformation formula takes the familiar form:

forall a. f a -> g a

The Yoneda lemma, which deals with natural transformations, can also be written using an end:

∫_{z}(C(a, z) -> f z) ≅ f a

In Haskell, we can write it as the equivalence:

forall z. ((a -> z) -> f z) ≅ f a

which is a generalization of the continuation passing transform.

The dual notion of coend is similarly written using an integral sign, with the “integration variable” in the superscript position:

∫^{a}p a a

In pseudo-Haskell, a coend is represented by an existential quantifier. It’s possible to define existential data types in Haskell by converting existential quantification to universal one. The relevant identity in terms of coends and ends reads:

(∫^{z}p z z) -> y ≅ ∫_{z}(p z z -> y)

In Haskell, this formula is used to turn functions that take existential types to functions that are polymorphic:

(exists z. p z z) -> y ≅ forall z. (p z z -> y)

Intuitively, it makes perfect sense. If you want to define a function that takes an existential type, you have to be prepared to handle any type.

The equivalent of the Yoneda lemma for coends reads:

∫^{z}f z × C(z, a) ≅ f a

or, in pseudo-Haskell:

exists z. (f z, z -> a) ≅ f a

(The intuition is that the only thing you can do with this pair is to `fmap`

the function over the first component.)

There is also a contravariant version of this identity:

∫^{z}C(a, z) × f z ≅ f a

where `f`

is a contravariant functor (a.k.a., a presheaf). In pseudo-Haskell:

exists z. (a -> z, f z) ≅ f a

(The intuition is that the only thing you can do with this pair is to apply the `contramap`

of the first component to the second component.)

Using coends we can define a tensor product in the category of functors `[C, Set]`

. This product is called Day convolution:

(f ★ g) a = ∫^{x y}f x × g y × C(x ⊗ y, a)

It is a bifunctor in that category (read, it can be used to lift natural transformations). It’s associative and symmetric up to isomorphism. It also has a unit — the hom-functor `C(i, -)`

, where `i`

is the monoidal unit in *C*. In other words, Day convolution imbues the category `[C, Set]`

with monoidal structure.

Let’s verify the unit laws.

(C(i, -) ★ g) a = ∫^{x y}C(i, x) × g y × C(x ⊗ y, a)

We can use the contravariant Yoneda to “integrate over x” to get:

∫^{y}g y × C(i ⊗ y, a)

Considering that `i`

is the unit of the tensor product in *C*, we get:

∫^{y}g y × C(y, a)

Covariant Yoneda lets us “integrate over y” to get the desired `g a`

. The same method works for the right unit law.

## Applicative as a Monoid

Given a monoidal category, we can always define a monoid as an object `m`

equipped with two morphisms:

μ :: m ⊗ m -> m η :: i -> m

satisfying the laws of associativity and unitality.

We have shown that the functor category `[C, Set]`

(with *C* a symmetric monoidal category) is monoidal under Day convolution. An object in this category is a functor `f`

. The two morphisms that would make it a candidate for a monoid are natural transformations:

μ :: f ★ f -> f η :: C(i, -) -> f

The `a`

component of the natural transformation μ can be rewritten as:

(∫^{x y}f x × f y × C(x ⊗ y, a)) -> f a

which is equivalent to:

∫_{x y}(f x × f y × C(x ⊗ y, a) -> f a)

or, upon currying:

∫_{x y}(f x, f y) -> C(x ⊗ y, a) -> f a

It turns out that so defined monoid is equivalent to a lax monoidal functor. This was shown by Rivas and Jaskelioff. The following derivation is due to Bob Atkey.

The trick is to start with the whole set of natural transformation from `f★f`

to `f`

. The multiplication μ is just one of them. We’ll express the set of natural transformations as an end:

∫_{a}((f ★ f) a -> f a)

Plugging in the formula for the `a`

component of μ, we get:

∫_{a x y}(f x, f y) -> C(x ⊗ y, a) -> f a

The end over `a`

does not involve the first argument, so we can move the integral sign:

∫_{x y}(f x, f y) -> ∫_{a}C(x ⊗ y, a) -> f a

Then we use the Yoneda lemma to “perform the integration” over `a`

:

∫_{x y}(f x, f y) -> f (x ⊗ y)

You may recognize this as a set of natural transformations that define a lax monoidal functor. We have established a one-to-one correspondence between these natural transformations and the ones defining monoidal multiplication using Day convolution.

The remaining part is to show the equivalence between the unit with respect to Day convolution and the second part of the definition of the lax monoidal functor, the morphism:

1 -> f i

We start with the set of natural transformations that contains our η:

∫_{a}(i -> a) -> f a

By Yoneda, this is just `f i`

. Picking an element from a set is equivalent to defining a morphism from the singleton set `1`

, so for any choice of η we get:

1 -> f i

and vice versa. The two definitions are equivalent.

Notice that the monoidal unit η under Day convolution becomes the definition of `pure`

in the Haskell version of applicative. Indeed, when we replace the category *C* with **Set**, `f`

becomes and endofunctor, and the unit of Day convolution `C(i, -)`

becomes the identity functor `Id`

. We get:

η :: Id -> f

or, in components:

pure :: a -> f a

So, strictly speaking, the Haskell definition of `Applicative`

mixes the elements of the lax closed functor and the monoidal unit under Day convolution.

## Acknowledgments

I’m grateful to Mauro Jaskelioff and Exequiel Rivas for correspondence and to Bob Atkey, Dimitri Chikhladze, and Make Shulman for answering my questions on Math Overflow.