anchor.diff:       (let ((p (make-hash-table :test 'equal)))
          (dolist (spec specification)
            (destructuring-bind (names &rest option-options
  -                                    &key type optional list negation
  +                                    &key type optional list negation (initial-value nil initial-value-p)
                                       action documentation negation-documentation)
                spec
  -           (declare (ignorable action documentation negation-documentation))
  +           (declare (ignorable action initial-value documentation negation-documentation))
  +           (when initial-value-p
  +             (setf optional t)
  +             (when list
  +               (error "Invalid option spec ~S: can't be a list and have an initial-value" spec)))
              (when list
                (unless (member type '(integer string))
  -               (error "option specification wants list but doesn't specify string or integer")))
  +               (error "option specification ~S wants list but doesn't specify string or integer" spec)))
              (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
  +             (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)))))))
  +                 (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)))
  +    (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)
  
positive.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 &allow-other-keys) spec
            (declare (ignorable negation documentation negation-documentation type optional list))
            (when documentation
              (format stream " ~25A  ~A~%"
                      (format nil "~{ ~A~}" (mapcar 'option-name names))
                      documentation))
            (when negation-documentation
              (format stream " ~25A  ~A~%"
                      (format nil "~{ ~A~}" (mapcar 'option-name (make-negated-names names negation)))
  
negative.code: 
  (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 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" "-h" "8080"
         "--no-port" "--port" "3" "--port=4"
         "--path" "/foo" "--path" "/bar"
         "--" "--foo" "bar" "baz"))
  