anchor.diff:             (alexandria:length= (assert value) 1)
              (first value)))))
   
  -(defmacro define-command (name-and-options params (&rest arg-descripters) &body body)
  +(defmacro define-command (name-and-options params (&rest arg-descriptors) &body body)
     (destructuring-bind (name . options) (uiop:ensure-list name-and-options)
       (let ((primary-class (primary-class options))
             (advice-classes (alexandria:assoc-value options :advice-classes))
  
positive.code:           exist-command-p))
  
  (eval-when (:compile-toplevel :load-toplevel)
    (defun gen-defcommand-arg-parser (universal-argument arg-descripters)
      (cond
        ((string= "p" (car arg-descripters))
         `(list (or ,universal-argument 1)))
        ((string= "P" (car arg-descripters))
         `(list ,universal-argument))
        ((string= "r" (car arg-descripters))
         `(progn
            (check-marked)
            (list (region-beginning) (region-end))))
        (t
         (cons 'list
               (mapcar #'(lambda (arg-descripter)
                           (cond
                             ((char= #\s (aref arg-descripter 0))
                              `(prompt-for-string ,(subseq arg-descripter 1)))
                             ((char= #\n (aref arg-descripter 0))
                              `(prompt-for-integer ,(subseq arg-descripter 1)))
                             ((char= #\b (aref arg-descripter 0))
                              `(prompt-for-buffer ,(subseq arg-descripter 1)
                                                  :default (buffer-name (current-buffer))
                                                  :existing t))
                             ((char= #\B (aref arg-descripter 0))
                              `(prompt-for-buffer ,(subseq arg-descripter 1)
                                                  :default (buffer-name (other-buffer))
                                                  :existing nil))
                             ((char= #\f (aref arg-descripter 0))
                              `(prompt-for-file
                                ,(subseq arg-descripter 1)
                                :directory (buffer-directory)
                                :default nil
                                :existing t))
                             ((char= #\F (aref arg-descripter 0))
                              `(prompt-for-file
                                ,(subseq arg-descripter 1)
                                :directory (buffer-directory)
                                :default nil
                                :existing nil))
                             (t
                              (error "Illegal arg-descripter: ~a" arg-descripter))))
                       arg-descripters)))))
  
    (alexandria:with-unique-names (arguments)
      (defun gen-defcommand-body (fn-name
                                  parms
                                  universal-argument
                                  arg-descripters)
        `(block ,fn-name
           ,(if (null arg-descripters)
                (progn
                  (assert (null parms))
                  `(,fn-name))
                `(destructuring-bind (&rest ,arguments)
                     ,(if (stringp (car arg-descripters))
                          (gen-defcommand-arg-parser universal-argument arg-descripters)
                          (car arg-descripters))
                   (apply #',fn-name ,arguments)))))))
  
  (defun primary-class (options)
  
negative.code:              ,(gen-defcommand-body name
                                     params
                                     universal-argument
                                     arg-descriptors)))))))
  
  #|
  ;;; example 1
  