Haskell is a language deeply rooted in category theory. But as you don’t need to study the root system of Vitis vinifera in order to enjoy a glass of wine, you don’t need to know much about category theory in order to program in Haskell. Nevertheless, some of us just can’t help ourselves. We have to dig into the rich terroir of category theory to gain deeper insight into the art of functional programming. And today I’d like to talk about functions.

The basic category-theoretical model for Haskell is the category **Hask**, where objects are Haskell types, and morphisms are functions. The problem with this picture is that it puts functions on a different footing than the rest of the language. Functions from type A to type B — in other words, morphisms from object A to object B in Hask — form a *set*. This set is called the hom set, Hom(A, B). The fact that it’s just a set and not something bigger is a property of Hask — the property of being *locally small*. But in Haskell functions from type A to type B also form a *type* A->B. A type is an object in Hask. So what’s the connection between the set Hom(A, B) and the object A->B? The answer to this question is very interesting and involves products, exponentials, currying, and of course universal constructions.

In my previous blog I talked about the universal construction of limits — objects that represent relationships between other objects. In particular, a product can be defined as such a limit representing the most trivial relationship between two objects — that of just being two objects. Morphisms are also involved in relationships between objects, so maybe there is a way of representing them as an object as well. And indeed, it’s possible to define an object to represent a set of morphisms between two other objects A and B. Such an object is called the *exponential* and denoted by B^{A}.

Notice that the domain A of the morphisms appears in the exponent. That might seem odd at first, but it makes perfect sense if you consider the relationship between multiplication (product) and exponentiation. In arithmetic, m^{n} means m multiplied by itself n times. If you replace m and n with types (for simplicity, think of types as sets of values) and multiplication with (set-theoretical) product, you can think of m^{n} as a set of n-tuples of values of type m: (m_{1}, m_{2}, m_{3},… m_{n}). Of course, if n is a type, it’s not immediately clear what an n-tuple is (it’s a categorical *power*), but you can gain some intuition if you consider enumerated finite types. For instance, functions from `Bool`

to any type `m`

, `Bool->m`

, can be represented as all possible pairs of `m`

s (one value for `True`

and one for `False`

). They correspond to the exponential `m`

. Also, for finite types, the number of different functions from n to m is equal to m^{Bool}^{n}. But the connection between products and exponentials goes deeper than that.

# Universal Construction

The basic relationship describing a function is that of application. Given a pair (function, argument), produce a result. It terms of types, a function of type `X->Y`

applied to `X`

produces `Y`

. We want to define the exponential object Y^{X} to model this relationship. How do we do that?

There isn’t really that much choice. We need to map a pair of objects (Y^{X}, X) to Y. But what is a pair, and what does it mean to map? We can represent the pair as an object — a product of Y^{X} × X — and then we can map it to Y using a morphism, which we’ll call `app`

.

It immediately follows that we can’t define exponential objects if we don’t have products. Again, it kind of make intuitive sense — exponentiation arising from iterated multiplication.

From previous experience we know that having a relationship between objects is usually not enough to define a new object. There may be many other objects that model this relationship. We need a way to compare them and pick the one that models it best.

So suppose that we have an impostor object Z, together with a morphism g from Z × X to Y impersonating application. We know that our choice for Y^{X} is universal if for any Z and g there is a unique morphism, which we’ll call λg, that maps Z to Y^{X}, and which factors through `app`

:

g = app . (λg, id)

Such universal object might not exist in every category, but it does in Hask. In general, a category in which there is a terminal object, a product of any two objects, and an exponential of any two objects is called *Cartesian closed*. Cartesian closed categories are, for obvious reasons, very important in computer science.

# Currying

There’s another way of looking at the diagram that defines the exponential object. You can think of the morphism g as a function of two variables:

g :: (Z, X) -> Y

For any such g there is a unique morphism λg that maps Z to Y^{X}, an object representing a function from X to Y. This establishes a one-to-one correspondence between functions of two variables and functions returning functions, which we know under the name of currying. So currying “falls out” of the definition of the exponential object.

# Adjunction

Any time there is a one-to-one correspondence between sets of morphisms you might want to look for an underlying adjunction. You might remember from my previous blog post that a functor F is said to be left adjoint to the functor G (or G right adjoint to F) if the following two hom sets are naturally isomorphic:

Hom(FZ, Y) ~ Hom(Z, GY)

In our case we have a one-to-one mapping between the morphism g from Z×X to Y and the morphism λg from Z to Y^{X}. In a category where all products and all exponentials exist, we can define these two functors:

F_{X}Z = Z × X G_{X}Y = Y^{X}

In Haskell, these functors would be implemented as:

newtype F x z = F (z, x) instance Functor (F x) where fmap f (F (z, x)) = F (f z, x) newtype G x y = G (x -> y) instance Functor (G x) where fmap f (G g) = G (f . g)

and the isomorphism of hom sets would be given by the function `phi`

and its inverse `phi'`

:

phi :: (F x z -> y) -> z -> G x y phi f z = G $ \x -> f (F (z, x)) phi' :: (z -> G x y) -> F x z -> y phi' g (F (z, x)) = let G f = g z in f x

Exponentiation can thus be defined as the right adjoint of taking a product.