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: ;; math-ov.lisp : definition of 'overloaded' mathematical operations
  
  (in-package #:math)
  
  ;; FIXME: This code does not evalute successfully in SBCL 
  ;; but this does evaluate successfully in CCL
  ;;
  ;; Versions tested
  ;; * SBCL 1.2.1 (MSWin x86-64)
  ;; * SBCL 1.2.3 (Linux x86-64)
  ;; * CCL 1.9-r15765 (windows x86-64)
  ;; 
  ;; Presumably, there may be something in how DEFOP is evaluted, in each
  ;; respective implementation.
  ;;
  ;; Specifically, the following forms do not evaluate successfully,
  ;; in those versions of SBCL:
  ;;
  ;; (%+ 1)
  ;;  --> wrong number of arguments: 2 (???)
  ;;
  ;; (@+ 1 1)
  ;;  --> The value (1 1) is not of type FIXNUM (????)
  ;;
  ;; Furthermore, the following form causes those versions of SBCL to
  ;; exhaust the control stack -- existing, on win32
  ;;
  ;;  (@+@ 1 2 3)
  ;;
  ;; siimlarly, though the following form should immediately result in
  ;; an error being signaled, but it results in the control stack being
  ;; exhausted, in SBCL:
  ;;
  ;; (@+@)
  ;;
  ;; Those forms have all been tested successfully in CCL.
  ;;
  ;;
  ;; It may have something to do with the method dispatching protocol in
  ;; SBCL's fork of PCL
  ;;
  ;; One notes the prevalence of SB-PCL::GF-DISPATCH calls in the backtrace
  ;; from the following:
  ;; (funcall (method-function (car (compute-applicable-methods-using-classes #'math::@+@ nil) )) 1 2 3)
  
  
  (eval-when (:compile-toplevel :load-toplevel :execute)
  
negative.code: ;; => 3
  
  ;; redefine @min@ to apply @< internally
  (defmethod @min@ (&rest values)
    (let ((top (car values))
  	(stack (cdr values)))
      (cond
        (stack
         (let* ((stack-min (apply #'@min stack))
  	      (top-lt-p (@< top stack-min)))
  	 (if top-lt-p top stack-min)))
        (t top))))
  
  ;; (%min 1)
  ;; => 1
  