anchor.diff:  
                    (add-method gf m))))
   
  -      (let* ((monadic-op-name (intern (format nil "%~A" op)))
  -	     (gf-monadic (ensure-gfn monadic-op-name '(a)))
  -	     (diadic-op-name (intern (format nil "@~A" op)))
  -	     (gf-diadic (ensure-gfn diadic-op-name  '(a b))))
  +      (let* ((monadic-op-name (when monadic-p
  +				(intern (format nil "%~A" op))))
  +	     (gf-monadic  (when monadic-p
  +			    (ensure-gfn monadic-op-name '(a))))
  +	     (diadic-op-name (when diadic-p
  +			       (intern (format nil "@~A" op))))
  +	     (gf-diadic (when diadic-p
  +			  (ensure-gfn diadic-op-name  '(a b)))))
           
   	(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 (function ,op) a b))
  -	    (makem gf-monadic op (list %c) '(a)
  -		   `(funcall (function ,op) a))))
  +	    (when diadic-p
  +	      (makem gf-diadic op (list %c %c) '(a b)
  +		     `(funcall (function ,op) a b)))
  +	    (when monadic-p
  +	      (makem gf-monadic op (list %c) '(a)
  +		     `(funcall (function ,op) a)))))
   	
   	(when default 
   	  ;; Define a diadic method specialized onto DEFAULT
  
positive.code:       (t (list c)))))
  )
  
  (defconstant* %numeric-instance-classes%
      (let ((the-end-classes
             (compute-end-classes (find-class 'number))))
        #+CCL
        (cons (find-class 'fixnum) the-end-classes)
        #-CCL
        the-end-classes))
  
  
  ;;; % Overloading for Comutative Functions
  
negative.code: 
  ;;; %% Miscellaneous Monadic Functions
  
  (labels ((defop-monadic (op &optional (classes %numeric-instance-classes%))
  	   (defop op :diadic-p nil :variadic-p nil
  		  :default nil)))
  
  ;;; %%% EXP
  
    (defop-monadic 'exp)
  
  ;;; %%% SIGNUM
  
    (defop-monadic 'signum)
  
  ;;; %%% SQRT, ISQRT
  
    (defop-monadic 'sqrt)
    (defop-monadic 'isqrt %integer-instance-classes%)
    
  ;;; %%% CIS
  
    (defop-monadic 'cis)
  
  ;;; %%% CONJUGATE
  
    ;: FIXME: Note for possible relevance within AC circuit analysis 
    ;; (RC / RL)
    
    (defop-monadic 'conjugate)
  
  ;;; %%% PHASE
  
    (defop-monadic 'phase)
  
  ;;; %%% Structural Accessor Functions
  
  ;;; %%%% REALPART, IMAGPART
    
    ;; NB: This is in leaving all of the optimization to the
    ;; implementation -- including any behaviors in numeric type
    ;; handling. In evaluation of DEFOP, notably the numeric OP is
    ;; declared as INLINE within each respective method lambda.
    ;;
    ;; Of course (%REALPART REAL) => REAL
    ;;           (%IMAGPART REAL) => ZERO
  
    (defop-monadic 'realpart) 
    (defop-monadic 'imagpart)
  
  ;;; %%%% NUMERATOR, DENOMINATOR
    
    (defop-monadic 'numerator %rational-instance-classes%)
    (defop-monadic 'denominator %rational-instance-classes%)
  
  ;;; %% Overloading for Monadic Predicate Functions
  
  ;;; %%% "Number-Line" Predicates
  
    (defop-monadic 'minusp)
    (defop-monadic 'plusp)
    (defop-monadic 'zerop)
  
  ;; %%% EVENP, ODDP
  
    (defop-monadic 'evenp)
    (defop-monadic 'oddp)
  
  
  ;;; %% Overloading for Monadic Increment Functions
  
  ;;; 1+, 1-
  
    (defop-monadic '1+)
    (defop-monadic '1-)
  
  ;;; INCF, DECF (?)
  
    ;; FIXME: Define overloaded macro forms for INCF, DECF
    ;; using GET-SETF-EXPANSION in each - possibly, applying %1+ and %1-
    ;; within the respective macroexpansions
  
  
  ;;; %% Overloading for Strictly Monadic Transcendental Functions
  
  ;; %%% SIN, COS, TAN
  
    (defop-monadic 'sin)
    (defop-monadic 'cos)
    (defop-monadic 'tan)
  
  ;; %%% ASIN, ACOS
  
    (defop-monadic 'asin)
    (defop-monadic 'acos)
  
    )
  
  ;;; % New Functions
  
  (defgeneric geometric-sum (a b)
    (:generic-function-class monotonic-generic-function)
    (:method ((a number) (b number))
      ;; FIXME: This completely looses optimizations,
      ;; though it does allow for overloaded math operations
      (%sqrt (@+ (@expt a 2) (@expt b 2)))))
  
  ;; (geometric-sum 3 4)
  ;; => 5.0
  
  ;; (geometric-sum 3d0 4d0)
  ;; => 5.0d0
  