anchor.diff:                      (alist-to-plist value)
                       value))))
   
  -(defun csv-to-hash-list (filename &key headers-in-file header-list
  +(defun hash-list-from-csv (filename &key headers-in-file header-list
                                       (clean-headers t))
     (let* ((rows (cl-csv:read-csv 
                   (if (pathnamep filename) filename (pathname filename))))
            (fields (cond
  +                   (header-list
  +                    (mapcar (lambda (k) (string-to-keyword k clean-headers))
  +                            header-list))
                      (headers-in-file
                       (mapcar (lambda (k) (string-to-keyword k clean-headers))
                               (car rows)))
  -                   (header-list
  -                    (mapcar (lambda (k) (string-to-keyword k clean-headers))
  -                            header-list))
                      (t (range 0 (1- (length (car rows))))))))
       (when (not (= (length (distinct-elements fields))
                     (length fields)))
  
positive.code: (defun alist-to-plist (alist &optional remove-star-prefix)
    (loop for (key . value) in alist
       appending (list 
                  (if (and remove-star-prefix (scan "^\\*.+" (format nil "~a" key)))
                      (string-to-keyword
                       (subseq (format nil "~a" key) 1))
                      key)
  
negative.code: 
  (defun make-keyword (name)
    (values (intern name "KEYWORD")))
  
  (defun qsort (sequence predicate &key (key 'identity))
    "Non-destructive Quicksort.  The sequence, predicate, and key parameters are the same as in the Common Lisp sort function."
    (when sequence
      (let* ((pivot (first sequence))
             (rest (rest sequence))
             (lesser (remove-if-not 
                      #'(lambda (x) (funcall predicate
                                             (funcall key x)
                                             (funcall key pivot)))
                      rest))
             (greater (remove-if-not 
                       #'(lambda (x)
                           (not (funcall predicate
                                         (funcall key x)
                                         (funcall key pivot))))
                       rest)))
        (append (qsort lesser predicate :key key)
                (list pivot)
                (qsort greater predicate :key key)))))
  