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" [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. ðŸ™‚

TVThe link to the tarball, http://lisp.asymptotic.co.uk/clojure/convex_hull.tar.gz, no longer exists. Is this available somewhere else, like GitHub perhaps? Thank you

adminPost authorThanks 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

https://github.com/timmartin/convex_hull

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.