Implementing the Graham Scan for a convex hull in Clojure

I saw implementation of the Graham scan mentioned in Real World Haskell as an exercise. I figured I’d have a go at doing it in Clojure, as it might prove useful for another project I was doing in a combination of Java and Clojure.

I’m mentioning this here as it really illustrated to me the power of Clojure basing itself on the JVM. During the development of this inherently graphical algorithm, I was able to quickly cobble together a Swing UI that showed what was going on. Working with the UI was very nearly as responsive as working at a REPL (indeed, UI elements were being drawn and redrawn as a result of commands from the REPL) and illustrated what was going on with the algorithm far better. For the first time ever I didn’t feel the dichotomy between dynamic and graphical ways of working with code.

I was also able to follow a very test-driven approach with test-is. This works so well at the REPL that it starts to make my work with C++ seem laughable.

The main body of the algorithm itself was something that seemed to fit well into Clojure’s loop construct as it’s inherently iterative rather than recursive. This was the first time I’ve done something where the loop seemed more natural than both the recursive solution and a for / while loop in C++. I tend to like declarations of intent in code, and listing the variables that are going to vary at the top of the loop seems like a sensible piece of discipline.

For what it’s worth, here’s the code of the main algorithm:

(defn make-convex-hull
  "Make a convex hull for a set of points, all of which are assumed to have positive x and y
coordinates. Returns a vector of lines, each of which is a sequence of two points"
  (let [starting-point (find-starting-point points)
        remaining-points (remove #(= % starting-point) points)
        working-set (sort angle-comparator remaining-points)]
    (loop [remaining-points working-set
           p1 starting-point
           p2 (first working-set)
           p3 (second working-set)
           hull []]
      (if (= p3 (last working-set))
        ; We have reached the end of the set, return the full hull
        (if (left-turn? p1 p2 p3)
          (concat hull [[p1 p2] [p2 p3] [p3 starting-point]])
          (concat hull [[p1 p3] [p3 starting-point]]))

        ; Does this form a left turn?
        (if (left-turn? p1 p2 p3)
          (recur (rest remaining-points) p2 p3 (nth remaining-points 2) (conj hull [p1 p2]))
          (recur (rest remaining-points) p1 p3 (nth remaining-points 2) hull))))))

You can also download a complete tarball. Note that this is a tarball of a darcs repository, so if you’re someone who might want to employ me you can see a full history of how I worked on the project. And if you’re a potential employer who knows how to use darcs, I might be interested in hearing from you. 🙂

2 thoughts on “Implementing the Graham Scan for a convex hull in Clojure

  1. admin Post author

    Thanks for taking an interest. It looks like this is pretty prehistoric code – I managed to retrieve it from one of my backups and it seems like it was a Darcs repository (remember when Git hadn’t yet taken over the world?)

    Anyway, I decided to rescue the code and put it on GitHub. It’s at

    There’s no build files or anything like that in the repo, so I don’t know how it was being built. And I’m sure the code is pretty minimal. Anyway, there it is.


Leave a Reply

Your email address will not be published. Required fields are marked *