anchor.diff:    "Same semantics as standard method combination but allows
   \"wrapping\" methods. Ordering of methods:
   
  - (around
  -    (before)
  -    (wrapping
  -      (primary))
  -    (after))
  + (wrap-around
  +   (around
  +     (before)
  +     (wrapping
  +       (primary))
  +     (after)))
   
  -:around, :wrapping and :primary methods call the next least/most
  -specific method via call-next-method (as in standard method
  -combination).
  +: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
  
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:         ;; 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)))
  
  