A mergesort implemented in Clojure; Takes any number of unordered lists and merges them into a single merged list.

mergesort.clj

(ns ward.mergesort
  (:refer-clojure :exclude [merge]))

(defn merge
  "Merges two sorted lists into a single sorted list."
  [right left]
  (flatten (loop [r right, l left, results []]
             (let [rhead (first r)
                   lhead (first l)]
               (cond (nil? rhead) (conj results l)
                     (nil? lhead) (conj results r)
                     (< (compare lhead rhead) 1) (recur (rest l) r (conj results lhead))
                     :else (recur l (rest r) (conj results rhead)))))))

(defn mergesort
  "Performs a mergesort on any number of unordered lists, producing a single ordered list."
  ([items]   
  (if (<= (count items) 1)
    items
    (let [midpoint (/ (count items) 2)
          left (mergesort (take midpoint items))
          right (mergesort (drop midpoint items))]
      (merge left right))))
    
  ([items & more]
   (let [merged-items (map mergesort (conj more items))]
     (reduce merge merged-items))))

Changed line 12 to use compare instead of the straight up < against the raw values. This allows the merge to now use anything that implements Comparable, including strings and, uh, other stuff.