**Introduction: lists galore**

I learned programming backwards, plunging right on into C and, shortly after, C++ and Java from the very beginning. I was knee deep in complex data structures, pointers and abstruse template syntax in no time. And the more complex it all felt, the more i thought i was learning. Of course, i was clueless.

Reading SICP and learning about functional programming changed it all. There were many occasions for revelation and awe, but one of my most vivid recollections of that time is my gradual discovery of the power of simplicity. At about half way into SICP i realised in wonder that that beautiful and powerful world was apparently being constructed out of extremely simple pieces. Basically, everything was a list. Of course there were other important ingredients, like procedures as first-class objects, but the humble list was about the only data structure to be seen. After mulling on it for a little bit, i saw where lists draw their power from: recursion. As you know, lists are data types recursively defined: a list is either the empty list or an element (its *head*) followed by another list (its *tail*):

list = []

list = a : list

where i’m borrowing Haskell’s notation for the empty list ([]) and the list constructor (:), also known by lispers as () and cons. So that was the trick, i thought: lists have recursion built-in, so to speak, and once you’ve read a little bit about functional programming you don’t need to be sold on the power and beauty of recursive programs.

It is often the case that powerful and beautiful yet simple constructs have a solid mathematical foundation, and only when you grasp it do you really realize how powerful, beautiful and amazingly simple that innocent-looking construct is. Lists, and recursive operations on them, are an excellent case in point. But the path connecting them to their mathematical underpinnings is a long and winding one, which lays in the realm of Category Theory.

I first became acquainted of the relationship between categories and recursive programming reading Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire, by Erik Meijer, Maarten Fokkinga and Ross Paterson. Albeit very enjoyable, this paper presupposes a high degree of mathematical sophistication on the reader’s side. I will try in this article to give you a simplified overview of the concepts involved, including Category Theory, its application to programming languages and what funny names like catamorphism, anamorphism or lambda-lifting have to do with your everyday list manipulations. Of course, i’ll be only scratching the surface: interspersed links and the Further reading section provide pointers to more in-depth explorations of this wonderland.

**Categorical interlude**

Categories are (relatively) simple constructs. A category consists of a set **O** of objects, and a set **A** of arrows between elements of **O**. Arrows are composable: if there’s an arrow from *a* to *b*, and another one from *b* to *c*, there must be an arrow from *a* to *c* (where *a*, *b* and *c* are elements of **O**). Besides, they are *associative*: if you have arrows from *a* to *b*, *b* to *c*, and *c* to *d*, you can go from *a* to *d* via two different paths, namely, first from *a* to *c* and then from *c* to *d*, or first from *a* to *b* and then from *b* to *d*. Finally, for each element *a* in **O** there’s an *identity* arrow which goes from *a* to itself (called an *identity*), such that following this arrow changes nothing. These properties are better visualized with a diagram (or a bit of mathematical notation), as shown in the image on the right.

A category captures a *mathematical world* of objects and their relationships. The canonical example of a category is **Set**, which contains, as objects, (finite) sets and, as arrows, (total) functions between them. But categories go far beyond modeling sets. For instance, one can define a category whose objects are natural numbers, and the ‘arrows’ are provided by the relation “less or equal” (that is, we say that there is an arrow joining two numbers *a* and *b* if *a *is less or equal than *b*)*.* What we are trying to do with such a definition is to somehow capture the essence of ordered sets: not only integers are ordered but also dates, lemmings on a row, a rock’s trajectory or the types of the Smalltalk class hierarchy. In order to abstract what all those categories have in common we need a way to go from one category to another preserving the shared structure in the process. We need what the mathematicians call an *isomorphism*, which is the technically precise manner of stating that two systems are, in a deep sense, analogous; this searching for commonality amounts to looking for concepts or abstractions, which is what mathematics and (good) programming is all about (and, arguably, intelligence itself, if you are to believe, for instance, Douglas Hofstadter‘s ideas).

To boot, our definition of a category already contains the concept of isomorphic objects. Think of an arrow from *a* to *b* as an operation that transforms *a* in *b*. An arrow from *b* to *a* will make the inverse transformation. If composing both transformations gives you the identity, you are back to the very same object *a*, and we say that *a* and *b* are isomorphic: you can transform one into the other and back at will. In a deep sense, this concept captures a generic way of expressing equality that pervades all maths: if you’re not afraid of a little bit of maths, Barry Mazur‘s essay When is a thing equal to some other thing? is an excellent introduction to Category Theory with an emphasis in the concept of equality. Among many other things, you will learn how the familiar natural numbers can be understood as a category, or how an object is completely defined by the set of its transformations (and, therefore, how to actually get rid of objects and talk only of transformations; i know this is stretching and mixing metaphors (if not plain silly), but this stress in arrows, as opposed to objects, reminded me of Alan Kay’s insistence on focusing on messages rather than objects). Another introductory article with emphasis on categories as a means to capture sameness is R. Brown and T. Porter’s Category Theory: an abstract setting for analogy and comparison.

Not only objects inside a category can be transformed into each other. We reveal the common structure of two disjoint categories by means of a functor mapping across two categories. A functor consists of two functions: one that maps each object of the first category to an object in the second, and another one putting in correspondence arrows in one category with arrows in the second. Besides, these functions must preserve arrow composition. Let me spell this mathematically. Consider to categories, C and C’ with object sets **O** and **O’** and arrow sets **A** and **A’**. A functor F mapping C to C’ will consist then of two functions (Fo, Fa); the first one taking elements of **O** to elements of **O’**:

Fo: **O** -> **O’**

Fo(a) in **O’** for every a in **O**

and the second one taking arrows from **A** to arrows in **A’**:

Fa: **A **-> **A’**

Fa(**f**) in **A’** for every **f** in **A**

and such that, if **f** is an arrow from a to b in C, Fa(**f**) is an arrow from Fo(a) to Fo(b) in C’. Moreover, we want that following arrows in C is ‘analogous’ to following them in C’, i.e., we demand that

Fa(**f****g**) = Fa(**f**)Fa(**g**)

In the left hand side above, we are composing two arrows in C and then going to C’, while in the right hand side we first take each arrow to C’ and, afterwards, compose them in there. If C and C’ have the same structure, these two operations must be equivalent. Finally, F must preserve identities: if **i** is the identity arrow for an element a in **O**, Fa(**i**)must be the identity arrow for Fo(a) in **O’**. The diagram on the left shows a partial graph (i’m not drawing the identity arrows and their mappings) of a simple functor between two categories, and ways of going from an object a in the first category to an object x in the second one which are equivalent thanks to the functor’s properties.

As you can see in this simple example, the functor gives us the ability of seeing the first category as a part of the second one. You get a category isomorphism in the same way as between objects, i.e., by demanding the existence of a second functor from C’ to C (you can convince yourself that such a functor does not exist in our example, and, therefore, that the two categories in the diagram are not isomorphic).

You have probably guessed by now one nifty property of functors: they let us going meta and define a category whose objects are categories and whose arrows are functors. Actually, Eilenberg and MacLane‘s seminal paper General theory of natural transformations used functors and categories of categories to introduce for the first time categories (natural transformations are structure-preserving maps between functors: this Wikipedia article gives an excellent overview on them).

But enough maths for now: it is high time to show you how this rather abstract concepts find their place in our main interest, programming languages.

**Categories and programming languages**

About the only similarity between C and Haskell programming is that one spends a lot of time typing ASCII arrows. But of course, Haskell’s are much more interesting: you use them to declare the type of a function, as in

floor:: Real -> Int

The above stanza declares a function that takes an argument of type real and returns an integer. In general, a function taking a single argument is declared in Haskell following the pattern

fun:: a -> b

where *a *and *b* are types. Does this ring a bell? Sure it does: if we identify Haskell’s arrows with categorical ones, the language types could be the objects of a category. As we have seen, we need identities

id:: a -> a

id x = x

and arrow composition, which in Haskell is denoted by a dot

f:: b -> c

g:: a -> b

fg:: a -> b -> c

fg = f . g

Besides, associativity of arrow composition is ensured by Haskell’s referential transparency (no side-effects: if you preserve referential transparency by writing side-effect free functions, it won’t matter the order in which you call them): we’ve got our category. Of course, you don’t need Haskell, or a statically typed language for that matter: any strongly typed programming language can be modelled as a category, using as objects its types and as arrows its functions of arity one. It just happens that Haskell’s syntax is particularly convenient, but one can define function composition easily in any decent language; for instance in Scheme one would have

(define (compose f g) (lambda (x) (f (g x)))

Functions with more than one arguments can be taken into the picture by means of currying: instead of writing a function of, say, 2 arguments:

(define (add x y) (+ x y))

(add 3 4)

you define a function which takes one argument (x) and returns a function which, in turn, takes one argument (y) and returns the final result:

(define (add x) (lambda (y) (+ x y)))

((add 3) 4)

Again, Haskell offers a pretty convenient syntax. In Haskell, you can define `add`

as:

add x y = x + y

which gets assigned, when applied to integers, the following type:

add:: Int -> (Int -> Int)

that is, `add`

is not a function from pairs of integers to integers, but a function that takes an integer and returns a function of type `Int -> Int`

. Finally, we can also deal with functions taking no arguments and constant values by introducing a special type, called unit or 1 (or void in C-ish), which has a unique value (spelled `()`

in Haskell). Constants of our language (as, e.g., `True`

or 43.23) are then represented by arrows from 1 to the constant’s type; for instance, `True`

is an `1 -> Boolean`

arrow. The unit type is an example of what in category theory is known as a terminal object.

Now that we have successfully modelled our (functional) programming language as a category (call it C), we can use the tools of the theory to explore and reason about the language constructs and properties. For instance, functors will let me recover the original motivation of this post and explore lists and functions on them from the point of view of category theory. If our language provides the ability to create lists, its category will contain objects (types) of the ‘list of’ kind; e.g. `[Int]`

for lists of integers, `[Boolean]`

for lists of Booleans and so on. In fact, we can construct a new sub-category CL by considering list types as its objects and functions taking and returning lists as its arrows. For each type a we have a way of constructing a type, [a] in the sub-category, i.e., we have a map from objects in C to objects in CL. That’s already half a functor: to complete it we need a map from functions in C to functions in CL. In other words, we need a way to transform a function acting on values of a given type to a function acting on lists of values of the same type. Using the notation of the previous section:

Fo(a) = [a]

Fa(f: a -> b) = f': [a] -> [b]

`Fa`

is better known as `map`

in most programming languages. We call the process of going from `f`

to `f'`

lifting (not to be confused with a related, but not identical, process known as lambda lifting), and it’s usually pretty easy to write an operator that lifts a function to a new one in CL: for instance in Scheme we would write:

(define (lift f) (lambda (lst) (map f lst)))

and for `lift`

to truly define a functor we need that it behaves well respect to function composition:

(lift (compose f g)) = (compose (lift f) (lift g))

We can convince ourselves that this property actually holds by means of a simple example. Consider the function `next`

which takes an integer to its successor; its lifting `(lift next)`

will map a list of integers to a list of their successors. We can also define `prev`

and `(lift prev)`

mapping (lists of) integers to (lists of) their predecessors. `(compose next prev)`

is just the identity, and, therefore, `(lift (compose next prev))`

is the identity too (with lifted signature). But we obtain the same function if we compose `(lift next)`

and `(lift prev)`

in CL, right? As before, there’s nothing specific to Scheme in this discussion. Haskell even has a Functor type class capturing these ideas. The class defines a generic lift operation, called `fmap`

that, actually, generalizes our list lifting to arbitrary type constructors:

fmap :: (a -> b) -> (f a -> f b)

where `f a`

is the new type constructed from `a`

. In our previous discussion, `f a = [a]`

, but if your language gives you a way of constructing, say, tuples, you can lift functions on given types to functions on tuples of those types, and repeat the process with any other type constructor at your disposal. The only condition to name it a functor, is that identities are mapped to identities and composition is preserved:

fmap id = id

fmap (p . q) = (fmap p) . (fmap q)

I won’t cover usage of type constructors (and their associated functors) other than lists, but just mention a couple of them: monads, another paradigmatic one beautifully (and categorically) discussed by Stefan Klinger in his Programmer’s Guide to the IO Monad – Don’t Panic (also discussed at LtU), and the creation of a dance and music library, for those of you looking for practical applications.

**To be continued…**

Returning to lists, what the lifting and categorical description above buys us is a way to formalize our intuitions about list operations, and to transfer procedures and patterns on simple types to lists. In SICP’s section on Sequences as conventional interfaces, you will find a hands-on, non-mathematical dissection of the basic building blocks into which any list operation can be decomposed: enumerations, accumulators, filters and maps. Our next step, following the bananas article i mentioned at the beginning, will be to use the language of category theory to provide a similar decomposition, but this time we will talk about catamorphisms, anamorphisms and similarly funny named mathematical beasts. What the new approach will buy us is the ability to generalize our findings beyond the list domain and onto the so-called algebraic types. But this will be the theme of a forthcoming post. Stay tunned.

The best introductory text on Category Theory i’ve read is Conceptual Mathematics : A First Introduction to Categories by F. William Lawvere (one of the fathers of Category Theory) and Stephen Hoel Schanuel. It assumes no sophisticated mathematical background, yet it covers lots of ground. If you feel at home with maths, the best option is to learn from the horse’s mouth and get a copy of Categories for the Working Mathematician, by Mac Lane.

The books above do not deal with applications to Computer Science, though. For that, the canonical reference is Benjamin Pierce’s Basic Category Theory for Computer Scientists, but i find it too short and boring: a far better choice is, in my opinion, Barr and Well’s Category Theory and Computer Science. A reduced version of Barr and Well’s book is available online in the site for their course Introduction to Category Theory. They are also the authors of the freely available Toposes, Triples and Theories, which will teach you everything about monads, and then more. Marteen Fokkinga is the author of this 80-pages Gentle Introduction to Category Theory, with a stress on the calculational and algorithmical aspects of the theory. Unless you have a good mathematical background, you should probably take gentle with a bit of salt.

Let me close by mentioning a couple of fun applications of Category Theory, for those of you that know a bit about it. Haskell programmers will like this implementation of fold and unfold (as a literate program) using F-(co)algebras and applied to automata creation, while those of you with a soft spot for Physics may be interested in John Baez’s musings on Quantum Mechanics and Categories.

Tags: category theory, haskell, maths, metaprogramming, scheme

March 18, 2006 at 9:04 am

Quite a Interesting

March 18, 2006 at 9:58 am

Elementary

March 18, 2006 at 5:29 pm

Hi,

Thanks for an introduction to Categories.

There is one thing which I don’t understand. (I might be just stupid). In the example why does there not exist an isomorphism between the categories? Don’t you get a reverse (if that is the word to use) functor by just reversing the arrows in the functor which goes from The 1st category to the 2nd? Or have I missed something obvious here?

March 18, 2006 at 9:50 pm

Go to Hades with your useless academic languages! There is a reason most people rejected LISP, Haskell and other idiotic languages and embraced C and C plus plus.

Academic languages are for idiotic inbred people like YOU

March 18, 2006 at 10:42 pm

If idiocy comes from inbreeding, I’d say that “up the nose” is descended from too many close relatives.

Don’t mock things you don’t understand, nose.

March 19, 2006 at 12:02 am

Thanks Jao, another great article!

March 19, 2006 at 5:33 pm

You’ve done an excellent job with this article. I know how hard it is to strike a balance between the “meat” of the article and helping readers get their feet wet with higher level mathematics, and I think you’ve hit the nail on the head. I’m looking forward to the next installment!

p.s. What did you use to draw the diagrams?

March 19, 2006 at 6:30 pm

Interesting.

Nose, if you can’t understand this then don’t post derigatory comments just because you don’t get it!!!

March 19, 2006 at 9:24 pm

Ted, i’ve used Dia (and a bit of patience) for the diagrams.

Punit, you don’t have a functor when you reverse the arrows because there are objects in C’ that don’t get an image in C. There is a subcategory in C’ which is isomorphic to C, but not C’ as a whole.

Thanks a lot to all for reading and the encouraging comments! :)

March 19, 2006 at 11:59 pm

“But of course, Haskell’s are much more you use them to declare the type of a function” – bad sentence

March 20, 2006 at 5:23 am

Nice article. Looking forward to part ii.

Guys, I’ve got to suspect that nose is some kind of crypto-ironist, maybe a friend of Jao’s. “Go to Hades”? No one has sworn like that since the mid 19th century…

March 22, 2006 at 9:39 am

Nice article, thanks. I started with functional programming only a short time ago and by the time I finished the Introduction to functional programming using Haskell from Richard Bird, there was still a big void remaining on Monads. They were described in the book, I just didn’t get it yet. I hope it will come eventually.

Just a short note: The “further reading” link points to the admin site – wordpress login is required. Would you mind to share that section as well? I would like to pick up a good book on this and there might be some good pointers.

Thanks, muro

March 22, 2006 at 10:24 am

muro,

Sorry, there was a typo in the anchor: the ‘further reading’ refers to the last section in the article itself, named, well, further reading :)

BTW, I liked Bird’s book a lot, but you won’t find much about monads in there. My preferred tutorial intro to monads is All about Monads (just in case you didn’t know it).

Thanks!

March 23, 2006 at 3:18 pm

Great, that’s how I understood it as well :-) just wasn’t sure, maybe I was missing something. Thanks.

I’ll have a look at the tutorial, thanks.

May 17, 2006 at 10:28 pm

[...] I’ve developed a lively interest in CT during my computer science wanderings , and even wrote an elementary introduction (geared towards programmers) that you may find useful (if you’re new to the field and don’t mind digressions into computer programming). [...]

May 26, 2006 at 12:20 pm

Thanks for a great article

June 20, 2006 at 4:08 am

Since you mention SICP, I thought my attempts at doing some translations of SICP to other languages (Alice ML, OCaml, Oz, and Haskell) might be of passing interest:

http://www.codepoetics.com/wiki/index.php?title=Topics:SICP_in_other_languages

Haven’t got real far just yet. More of a long term recreational project.

July 8, 2006 at 6:18 pm

Thanks, great article!

I’m waiting for the continuuation…

July 27, 2006 at 3:04 am

[...] This looks pretty much like the previous example. But here, instead of map, we have lift, which takes only one argument, a function, and returns a new function that applies that function to every element of a list. That new function is then applied (here, in a Scheme-like syntax) to the list argument. I learned about lift from this blog article. [...]

December 18, 2006 at 3:57 pm

Excellent article. I also started with SICP, which lead to Haskell. In order to understand important aspects of functional programming I have come to believe that I need to understand a bit of category theory. Your essay helps, thanks.

March 8, 2007 at 9:32 pm

Referential transparency is a nice property to have, but not needed for associativity of composition.

Unit, 1, or (), having a single element, is very different from void, which has none. Categorically, that makes the difference between a terminal and an initial object.

Monads are not type constructors like lists, they are a completely different kind of beasts. A monad is a concept for which lists happen to be an example.

January 22, 2009 at 6:09 pm

Great article!

I have been wondering for a while how category theory and haskell relate as it was mentioned on #haskell. This article gave me some new insight and new ideas. I have now a better understanding of what a functor is. The Further Reading section is also a great starting point.

February 6, 2009 at 1:33 am

Minor nit pick-

Shouldn’t the type of fg above be a -> b?

January 2, 2011 at 6:04 pm

[...] Programmers go bananas March 2006 23 comments 5 [...]

January 23, 2011 at 1:48 am

[...] recently on Category Theory, and it’s application to programmable systems, called, “Programmers go bananas,” by José Ortega-Ruiz, that “isomorph” is a term used in mathematics. Just [...]