anchor.diff:                         :lambda-list ',lambda-list
                          :participants (list ,@participants)
                          :documentation ,docstring
  -                       :function ,(make-reply-lambda name lambda-list ignorable body))))))
  +                       :function ,(make-reply-lambda name lambda-list ignorable
  +          #|| FIXME: This is such a kludge ||#       (append declarations body)))))))
   
   (defun make-reply-lambda (name lambda-list ignorable body)
     (with-gensyms (args next-erfun reply-function)
  
positive.code:            (declare (inline ,reply-function))
             (apply #',reply-function ,args))))))
  
  (defun parse-defreply (args)
    (let ((qualifiers nil)
          (lambda-list nil)
          (docstring nil)
          (body nil)
          (parse-state :qualifiers))
      (dolist (arg args)
        (ecase parse-state
          (:qualifiers
           (if (and (atom arg) (not (null arg)))
               (push arg qualifiers)
               (progn (setf lambda-list arg)
                      (setf parse-state :docstring))))
          (:docstring
           (if (stringp arg)
               (setf docstring arg)
               (push arg body))
           (setf parse-state :body))
          (:body (push arg body))))
      (values qualifiers lambda-list docstring (nreverse body))))
  
  ;;; Undefinition
  (defmacro undefreply (name &rest args)
  
negative.code: ;;;
  
  ;;; Definition
  (defmacro defreply (&whole whole name &body defreply-body)
    (declare (ignore defreply-body))
    (multiple-value-bind (qualifiers reply-ll declarations docstring body)
        (parse-defreply whole)
      (multiple-value-bind (parameters lambda-list participants required ignorable)
          (parse-specialized-lambda-list reply-ll)
        (declare (ignore parameters required))
  