Lisp: Roman Numerals

(defun romanval (x)
  (cond
    ((eq x #\M) 1000)
    ((eq x #\D) 500)
    ((eq x #\C) 100)
    ((eq x #\L) 50)
    ((eq x #\X) 10)
    ((eq x #\V) 5)
    ((eq x #\I) 1)))

(defun strtolist (str)
  (let ((l (length str)))
    (do ((i 0 (+ i 1))
         (lst nil (push (char str i) lst)))
        ((>= i l) (reverse lst)))))

(defun charstoroman (chars)
  (labels ((rec (src dest)
             (cond
               ((null src) (reverse dest))
               (t
                 (push (romanval (car src)) dest)
                 (rec (cdr src) dest)))))
    (rec chars nil)))

(defun calcroman (lst)
  (labels ((rec (src last sum)
             (cond
               ((null src) sum)
               (t
                 (rec (cdr src) (car src)
                   (if (< (car src) last)
                       (- sum (car src))
                       (+ sum (car src))))))))
    (rec (reverse lst) 0 0)))

(defun romantoi (str)
  (calcroman (charstoroman (strtolist str))))

(defun implode (list)
  "The inverse of explode; implode returns a string representation of a list
  object."
  (coerce list 'string))

(defun explode (string)
  "The inverse of implode; explode returns a list representation of a string."
  (coerce string 'list))

(defun roman-digit->arabic (v)
  "Converts a given single roman numeral into its equivalent arabic value."
  (case v
    ;; Maps each character used in the roman number system onto their value.
    ;; Returns the value corresponding to V or NIL otherwise.
    (#\M 1000)
    (#\D 500)
    (#\C 100)
    (#\L 50)
    (#\X 10)
    (#\V 5)
    (#\I 1)))

(defun roman->arabic-helper (rest last sum)
  "A none-strict utility that converts roman numerals into equivalent arabic
  numbers; works on a list of numbers :)."
  (if (consp rest)
    (let ((this (car rest))
          (rest (cdr rest)))

      ;; Recursively calls roman->arabic-helper on the rest of the list; if
      ;; the last number was less than this one then subtract the new value,
      ;; else add them 0_o.
      (roman->arabic-helper rest this 
          (funcall (if (< last this) ; Return and evaluate the +/- function.
                     #'-
                     #'+)
                   this sum)))
    sum)) ;Returns sum once the whole list has been processed.

(defun roman->arabic (v)
  "Called to convert a roman numeral into it's fully expanded arabic form."
  (roman->arabic-helper
      ;; Calls roman-digit->arabic-value on each item of the newly coerced
      ;; list of characters.
      (mapcar #'roman-digit->arabic
          (coerce v 'list))
      0 0))

          (funcall (if (< last this)
                     #'-
                     #'+)
                   this sum)))

          (funcall (if (< this last)
                     #'-
                     #'+)
                   sum this)))