Relating Category Theory to Programming Language Theory I'm wondering what the relation of category theory to programming language theory is.
I've been reading some books on category theory and topos theory, but if someone happens to know what the connections and could tell me it'd be very useful, as that would give me reason to continue this endeavor strongly, and know where to look.
Motivation: I'm currently researching undergraduate/graduate mathematics education, specifically teaching programming to mathematics grads/undergrads. I'm toying with the idea that if I play to mathematicians strengths I can better instruct them on programming and they will be better programmers, and what they learn will be useful to them. I'm in the process (very early stages) of writing a textbook on the subject.
 A: The most immediately obvious relation to category theory is that we have a category consisting of types as objects and functions as arrows. We have identity functions and can compose functions with the usual axioms holding (with various caveats). That's just the starting point.
One place where it starts getting deeper is when you consider polymorphic functions. A polymorphic function is essentially a family of functions, parameterised by types. Or categorically, a family of arrows, parameterised by objects. This is similar to what a natural transformation is. By introducing some reasonable restrictions we find that a large class of polymorphic functions are in fact natural transformations and lots of category theory now applies. The standard examples to give here are the free theorems.
Category theory also meshes nicely with the notion of an 'interface' in programming. Category theory encourages us not to look at what an object is made of, but how it interacts with other objects, and itself. By separating an interface from an implementation a programmer doesn't need to know anything about the implementation. Similarly category theory encourages us to think about objects up to isomorphism - it doesn't precisely proclaim which sets our groups comprise, it just matters what the operations on our groups are. Category theory precisely captures this notion of interface.
There is also a beautiful relationship between pure typed lambda calculus and cartesian closed categories (CCC). Any expression in the lambda calculus can be interpreted as the composition of the standard functions that come with a CCC: like the projection onto the factors of a product, or the evaluation of a function. So lambda expressions can be interpreted as applying to any CCC. In other words, lambda calculus is an internal language for CCCs. This is explicated in Lambek and Scott. This means for instance that the theory of CCCs is deeply embedded in Haskell, because Haskell is essentially pure typed lambda calculus with a bunch of extensions.
Another example is the way structural recursion over recursive datatypes can be nicely described in terms of initial objects in categories of F-algebras. You can find some details here.
And one last example: dualising (in the categorical sense) definitions turns out to be very useful in the programming languages world. For example, in the previous paragraph I mentioned structural recursion. Dualising this gives the notions of F-coalgebras and guarded recursion and leads to a nice way to work with 'infinite' data types such as streams. Working with streams is tricky because how do you guard against inadvertently trying to walk the entire length of a stream causing an infinite loop? The appropriate dual of structural recursion leads to a powerful way to deal with streams that is guaranteed to be well behaved. Bart Jacobs, for example, has many nice papers in this area.
A: You may enjoy The Algebra of Joy which "gives several analogues of concepts from category theory."
A: If you want a very basic, entry level description of category theory from a Haskell programming point of view (not exactly what the OP asked for),


*

*http://en.wikibooks.org/wiki/Haskell/Category_theory
is nice.
A: Lambek & Scott, "Introduction to higher order categorical logic" is one classic book on the subject.
What language are you (researching?) teaching to these math students?  IMHO Haskell is easier to learn than close-to-the-metal languages for mathematically minded people without prior programming experience.
A: Couple of related works:


*

*Tatsuya Hagino "A Categorical Programming Language"

*Pierre-Louis Curien "Category Theory: a programming language oriented introduction"

*D.E. Rydeheard, R.M. Burstall "Computational Category Theory"

*Dr. Steve Easterbrook "An introduction to Category Theory for Software Engineers"

*Eugenio Moggi "A Category-theoretic account of program modules"

*Joseph A. Goguen "A Categorical Manifesto"

*Varmo Vene "Categorical Programming with Inductive and Coinductive Types"

*Martin Erwig "Categorical Programming with Abstract Data Types"

*Eugenio Moggi "An Abstract View of Programming Languages"
A: A lot of work has been done in this area. As mentioned above, there is an essential correspondence between the $\lambda$-calculus and Closed Cartesian Categories. Moggi's seminal work Notions of Computations and Monads developed a unified way of treating many computational effects. This of course inspired Haskell's current approach to dealing with IO, State, Concurrency and so forth. The dual approach, Comonadic Notions of Computation by Tarmo Uustalu and Varmo Vene, captures a other notions, such as stream based computation. Classes and object-oriented languages can be modelled using coalgebra (also mentioned above). A general reference to the coalgebraic approach is Universal Coalgebra: A Theory of Systems by Jan Rutten, and articles showing how to apply it to object-oriented languages include Reasoning about Classes in Object-Oriented Languages: Logical Models and Tools and Coalgebraic Reasoning about Classes in Object-Oriented Languages by Bart Jacobs and colleagues. Although these are aimed at reasoning about programs, they do give semantics for the relevant programming languages along the way.
A: Baez' article, the discussion and Manin's article are perhaps interesting for you.
A: The connections I have seen are in the area of denotational semantics and type theory.  For example, the objects can be the types: Integer, List(Integer), Integer+List(List(Integer)), etc.  Functions (in the language) are arrows between the objects.  (So the successor function is an arrow from Integer to Integer.)  Then categorical constructions translate into programming language constructs ("List" is an endo-functor, for example).  The existence of recursive functions is guaranteed by certain categorical properties of the category, etc.
A: If you want to get your hands dirty, look into the programming language Haskell, which has functors and natural transformations.
Functors implement structure. For instance, consider the category of types T and a functor L that sends a type t to the type L(t), lists of t. This is somewhat similar to the functor on Set that sends a set X to the set of all finite lists on the set X (i.e. the underlying set of the free monoid on X). You could also consider a functor B that sends a type t to the type B(t) of a binary tree on t.
Now you can define a natural transformation from B(t) to L(t) such as flatten, which takes a binary tree and flattens it to a list. So as functors implement structure, natural transformations alter structure.
It gets interesting when you bring in monads. Using the list functor above, think about L(L(t)), lists of lists. You can concatenate a list of lists to a single list, which corresponds to the monad map L(L(t)) to L(t).
Check out this link for more.
