I started learning Haskell after reading about the programming language in the answers to the MathOverflow question “What programming languages do mathematicians use?” Its alleged elegance sold me on the language. Although I’ve barely gotten my feet wet, I am already impressed with Haskell. I want to share an example of its elegance with you today.

Haskell’s lazy evaluation allows us to create infinite data structures, such as infinite lists. Haskell also allows for circular references; we can reference a function in its own definition in a way that is not explicitly recursive. Using this freedom, we can create an infinite list of factorials with just two lines of code, one of which is a type declaration.

fact :: [Integer]
fact = 1:(zipWith (*) fact [1..])

The nth iteration of the zipWith function multiplies the nth element of the positive integers (1..n) by the nth element of the list fact, which is $(n-1)!$, to create the nth element of a new list. zipWith function exploits the basic property $n!=n\cdot (n-1)!$. Since we define a base case $0!=1$ by prepending a 1 to the list returned by zipWith , we see that the recursion is well-defined.

To obtain a list of just the factorials up to some nonnegative integer $n$ (e.g. $[0!,1!,\ldots,n!]$), we use the take function with arguments $n$ and fact. For example, if $n=10$, then

ghci> take 10 fact
[1,1,2,6,24,120,720,5040,40320,362880]