anchor.diff:  
   (defparameter *opt-spec*
    '((("all" #\a) :type boolean :documentation "do it all")
  +   ("blah" :type string :initial-value "blob" :documentation "blah")
      (("verbose" #\v) :type boolean :documentation "include debugging output")
      (("file" #\f) :type string :documentation "read from file instead of standard input")
      (("xml-port" #\x) :type integer :optional t :documentation "specify port for an XML listener")
  +   (("http-port" #\h) :type integer :initial-value 80 :documentation "specify port for an HTTP listener")
      ("enable-cache" :type boolean :documentation "enable cache for queries")
      ("path" :type string :list t :optional t :documentation "add given directory to the path")
      ("port" :type integer :list (:initial-contents (1 2)) :optional t :documentation "add a normal listen on given port")))
   
  -(defun foo (args &key all verbose file xml-port enable-cache port path)
  -  (list args :all all :verbose verbose :file file :xml-port xml-port
  +(defun foo (args &key all verbose file xml-port enable-cache port path http-port blah)
  +  (list args :all all :verbose verbose :file file :xml-port xml-port :http-port http-port :blah blah
           :enable-cache enable-cache :port port :path path))
   
   (multiple-value-bind (options arguments)
       (process-command-line-options
        *opt-spec*
        '("--all" "--no-verbose" "--file" "foo" "-f" "-v" "-v"
  -       "-x" "--disable-cache"
  +       "-x" "--disable-cache" "-h" "8080"
          "--no-port" "--port" "3" "--port=4"
          "--path" "/foo" "--path" "/bar"
          "--" "--foo" "bar" "baz"))
  
positive.code:      (let ((p (make-hash-table :test 'equal)))
         (dolist (spec specification)
           (destructuring-bind (names &rest option-options
                                      &key type optional list negation
                                      action documentation negation-documentation)
               spec
             (declare (ignorable action documentation negation-documentation))
             (when list
               (unless (member type '(integer string))
                 (error "option specification wants list but doesn't specify string or integer")))
             (let* ((namelist (if (listp names) names (list names)))
                    (firstname (car namelist))
                    (pos-action (apply 'make-option-action p firstname option-options)))
               ;; For each name of this spec, put an entry into the hash table
               ;; mapping that name to a vector of the action, the type, and
               ;; whether it's optional.
               (loop with spec = (vector pos-action type (and optional (not list)))
                     for name in namelist do
                     (setf (gethash name p) spec))
               ;; Deal with negation.
               (when (or (eq type 'boolean) list optional)
                 (let ((neg-action #'(lambda (value)
                                       (command-line-action pos-action (not value))))
                       (neg-names (make-negated-names namelist negation)))
                   (loop with spec = (vector neg-action nil nil nil)
                         for name in neg-names do
                         (setf (gethash name p) spec)))))))
         p))))
  
  (defun make-negated-names (namelist &optional negation)
    (let ((negation-list (if (listp negation) negation (list negation))))
      (loop for name in namelist
            when (stringp name) do
            (push (concatenate 'string "no-" name) negation-list)
            (when (and (<= 7 (length name))
                       (string= "enable-" (subseq name 0 7)))
              (push (concatenate 'string "disable-" (subseq name 7 nil))
                    negation-list)))
      negation-list))
  
  (defun command-line-option-specification (option)
  
negative.code:   ;; TODO: be clever when trying to align stuff vertically
    (loop :for spec :in specification :do
          (destructuring-bind (names &key negation documentation negation-documentation
                                     type optional list (initial-value nil initial-value-p) &allow-other-keys) spec
            (declare (ignorable negation documentation negation-documentation type optional list))
            (unless (consp names)
              (setf names (list names)))
            (when documentation
              (format stream "~& ~25A  ~A~:[~*~; (default: ~S)~]~%"
                      (format nil "~{ ~A~}" (mapcar 'option-name names))
                      documentation
                      initial-value-p initial-value))
            (when negation-documentation
              (format stream " ~25A  ~A~%"
                      (format nil "~{ ~A~}" (mapcar 'option-name (make-negated-names names negation)))
  