The Evolution of a Lisp Programmer


I really enjoyed reading the blog post The Evolution of a Haskell Programmer by Fritz Ruehr on

I thought I’d try to do something similar for Lisp, based on uLisp, although I haven’t quite managed to take it to the same extremes as the original!

These programs will work using uLisp on any 32-bit board, or using Common Lisp.

Newcomer to Lisp - writes in C style

(defun fac (n)
  (let ((f 1))
    (dotimes (i n)
      (setq f (* (1+ i) f)))
> (fac 11)

Computer science student - has discovered the joy of recursion

(defun fac (n)
  (if (zerop n) 1 (* n (fac (1- n)))))
> (fac 11)

Second year computer science student; more efficient recursive version using an accumulator

(defun facacc (a n)
  (if (zerop n) a (facacc (* n a) (1- n))))

(defun fac (n) (facacc 1 n))
> (fac 11)

Generalist - can’t resist turning it into a more general problem

(defun product (a b)
  (if (= a b) a (* a (product (1+ a) b))))

(defun fac (n) (product 1 n))
> (fac 11)

Haskell programmer - first creates a recursive Lisp equivalent for the ‘..’ operator

(defun dotdot (from to)
  (if (> from to) nil (cons from (dotdot (1+ from) to))))

(defun fac (n) (apply #'* (dotdot 1 n)))
> (dotdot 1 11)
(1 2 3 4 5 6 7 8 9 10 11)

> (fac 11)

Purist Lisp programmer - uses lists, because numbers aren’t really pure Lisp!

(defun mul (a b)
   ((null a) nil)
   ((null (cdr a)) b)
   (t (append b (mul (cdr a) b)))))

(defun fac (n)
   ((null n) '(x))
   (t (mul n (fac (cdr n))))))
> (fac '(x x x x))
(x x x x x x x x x x x x x x x x x x x x x x x x)

Any other suggestions or contributions welcomed!


I think Alonzo Church might want a word.