Converting to and from Roman numerals
Looking at int-&gt;roman ... 


It simply ignores digits that are too big. 10000 maps to ""!
Surely better to repeat the biggest signifier as often as necessary.
The logic for the  one five ten units for digit is in your head. We can derive them from a list of the symbols in increasing order. And it's easier to wrap them as a single argument to digit. 
I've done the string concatenation within digit.
I've dumped the base argument and done the digit-ising inline.


For what it's worth ... 

(def symbols "IVXLCDM")

(defn digit [[one five ten] n]
  (let [chars (case n
                4 [one five]
                9 [one ten]
                (cons (when (&lt;= 5 n) five)
                      (repeat (mod n 5) one)))]
    (apply str chars)))

(defn int-&gt;roman
  "Returns the Roman numeral representation of n."
  [n]
  {:pre [(integer? n) (pos? n) (odd? (count symbols))]}
  (let [triples (partition 3 2 symbols)
        heads (-&gt;&gt; n (iterate #(quot % 10)))
        digits (map (fn [t i] (digit t (mod i 10))) triples heads)
        left-over (nth heads (count triples))
        left-overs (-&gt;&gt; (last symbols)
                        (repeat left-over)
                        (apply str))]
    left-over
    (-&gt;&gt; (concat digits left-overs)
         reverse
         (apply str))))


For example, 

(int-&gt;roman 11976)
;"MMMMMMMMMMMCMLXXVI"


It could be made faster as a big fat reduce, but I prefer it slow and fairly clear. It gave me enough trouble!