anchor.diff:          ;; wrap FORM in calls to its around methods
           (setf form `(call-method ,(first around)
                                    (,@(rest around)
  +                                    (make-method ,form)))))
  +      (when wrap-around
  +        (setf form `(call-method ,(first wrap-around)
  +                                 (,@(rest wrap-around)
                                       (make-method ,form)))))
         form)))
   
  
positive.code:              (mapcar (lambda (meth) `(call-method ,meth))
                       methods)))
      (let* (;; reorder the methods based on the -order arguments
             (around (effective-order around around-order))
             (wrapping (effective-order wrapping wrapping-order))
             (before (effective-order before before-order))
  
negative.code:   "Same semantics as standard method combination but allows
  \"wrapping\" methods. Ordering of methods:
  
   (wrap-around
     (around
       (before)
       (wrapping
         (primary))
       (after)))
  
  :warp-around, :around, :wrapping and :primary methods call the
  next least/most specific method via call-next-method (as in
  standard method combination).
  
  The various WHATEVER-order keyword arguments set the order in
  which the methods are called and be set to either
  