anchor.diff:    ;; classes, but it will not allow for optimizations onto types
     ;; derived of numeric classes, e.g. signed/unsigned values
   
  -  (let* ((monadic-op-name (intern (format nil "%~A" op)))
  -         #+SBCL (src (sb-c:source-location))
  -         (gf-monadic
  -          (ensure-generic-function monadic-op-name
  -                                   :lambda-list '(a)
  -                                   :argument-precedence-order '(a)
  -                                   #+SBCL :definition-source #+SBCL src
  -                                   ))
  -         (diadic-op-name (intern (format nil "@~A" op)))
  -         (gf-diadic 
  -          (ensure-generic-function diadic-op-name
  -                                   :lambda-list '(a b)
  -                                   :argument-precedence-order '(a b)
  -                                   #+SBCL :definition-source #+SBCL src
  -                                   )))
  -        
  +  (let (#+SBCL (src (sb-c:source-location)))
       (labels ((mklambda  (ll op specializers form)
                  `(lambda ,ll 
                     (declare (inline ,op)
  
positive.code:                                                `(type ,(class-name c) ,arg))
                                             ll specializers)))
                    ,form))
               (makem (gf op specializers lambda form)
                 (let* ((lform (mklambda lambda op specializers form))
                        (m
                         (progn 
                           #+NIL (warn "FOO ~S" lform)
                           (make-instance
                            'standard-method 
                            :specializers specializers
                            :lambda-list lambda
                            #+SBCL :definition-source #+SBCL src
                            :function (compile nil lform)))))
                   (add-method gf m))))
      
        (dolist (c classes)
          (let* ((%c (compute-class c)))
            ;; Define methods for diadic and monadic functions
            ;; specialized onto each C
            (makem gf-diadic op (list %c %c) '(a b)
                   `(funcall ,(fdefinition op) a b))
            (makem gf-monadic op (list %c) '(a)
                   `(funcall ,(fdefinition op) a))))
        
        (when default 
          ;; Define a diadic method specialized onto DEFAULT
          ;;
          ;; NB: In some implementations, this "default" method may
          ;; effectively loose compiler optimizations, such that may be
          ;; available for some instances of A and B delcared
          ;; explicitly for their respective numeric types -- moreover,
          ;; in instances when the classes of A and B are not EQ.
          ;;
          ;; With OP declared incline, however, maybe it would be
          ;; possible for the compiler to further optimize the following
          ;; form.
          (let ((%c (compute-class default)))
            (makem gf-diadic op (list %c %c) '(a b)
                   `(funcall ,(fdefinition op) a b))))
  
        (cond
          (variadic-p
           ;; Define a variadic function.
           ;;
           ;; FIXME: This produces a generic function that canot be
           ;; any further specialized
           (let* ((variadic-op-name (intern (format nil "@~A@" op)))
                  (gf-variadic 
                   (ensure-generic-function variadic-op-name
                                            :lambda-list '(&rest values)
                                            #+SBCL :definition-source #+SBCL src
                                            )))
             (makem gf-variadic op nil '(&rest values)
                    `(progn
                      (unless (consp values)
                        (simple-program-error 
                         `,(format* "~A called with no arguments"
                                    (quote ,variadic-op-name))))
                      (let ((rest (cdr values)))
                        (cond
                          (rest 
                           (funcall ,gf-diadic 
                                    (car values)
                                    (apply ,gf-variadic rest)))
                          (t (funcall ,gf-monadic (car values)))))))
  
             (values gf-diadic gf-monadic gf-variadic)))
          (t (values gf-diadic gf-monadic nil))))))
  
  ;;; % Overloading for Monadic/Diadic/Variadic Functions
  
  
negative.code: (defop 'min)
  
  ;; redefine @max@ to apply @> internally
  (defmethod @max@ (&rest values)
    (let ((top (car values))
  	(stack (cdr values)))
      (cond
        (stack
         (let* ((stack-max (apply #'@max stack))
  	      (top-gt-p (@> top stack-max)))
  	 (if top-gt-p top stack-max)))
        (t top))))
  
  ;; (%max 1)
  ;; => 1
  