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: 
  ;;; % GCD, LCM
  
  ;;; % Overloading for Strictly Diadic, Non-Comutative Functions
  
  ;;; %% Exponentiation with arbitrary degree
  
  (defgeneric @expt (a b)
    (:method ((a number) (b number))
      (expt a b)))
  
  ;;; %% MOD, REM
  
  ;;; % Overloading for Alternately Monadic/Diadic Functions
  
  
negative.code: 
  ;; %% ATAN
  
  (defop 'atan :variadic-p nil)
  
  ;; (= (/ pi 4) (%atan 1d0))
  ;; => T
  
  ;; (= (/ pi 4) (@atan 2d0 2d0))
  ;; => T
  
  ;; also
  ;; (= (rationalize (/ pi 4d0)) (rationalize (@atan 2d0 2d0)))
  ;;
  ;; although
  ;; (= (/ (rationalize pi) 4) (rationalize (@atan 2d0 2d0)))
  ;; => NIL
  ;;
  ;; however
  ;; (= (/ (rational pi) 4) (rational (@atan 2d0 2d0)))
  ;; => T
  ;;
  ;; furthermore
  ;; (= (rationalize (/ pi 4d0)) (rationalize (@atan 2d0 2d0)))
  ;; => T
  ;;
  ;; thus illustrating some of the contrasting qualities of CL:RATIONAL 
  ;; and CL:RATIONALIZE - onto that simple wrapper for diadic ATAN
  
  ;; Considering the examples in the previous, it may seem to be
  ;; advisable to apply a methodology of using DOUBLE-FLOAT values,
  ;; internally, with RATIONALIZE applied when a rational return value
  ;; is sought?
  
  ;; furthermore:
  ;;
  ;; (defun rad-to-deg (r) (* r #.(/ 180 (rationalize pi))))
  ;; 
  ;; double-float=>rational=>..=>ratio onto pi/4 via effective (atan 1d0)
  ;; (rad-to-deg (rational (atan 2d0 2d0)))
  ;; => <large ratio>
  ;;
  ;; double-float=>rational=>...=>ratio=>single-float onto pi/4 via effective (atan 1d0)
  ;; (float (rad-to-deg (rational (atan 2d0 2d0))))
  ;; => 45.0
  ;;
  ;; furthermore, redefining RAD-TO-DEG
  ;;
  ;; (defun rad-to-deg (r) (rational (* r #.(/ 180d0 pi))))
  ;;; ^ double-float => rational (consistently)
  ;;
  ;; (rad-to-deg (/ pi 4))
  ;; => 45
  ;;
  ;; lastly:
  ;;
  ;; (defun rad-to-deg (r) (rationalize (* r #.(/ 180d0 pi))))
  ;; (rad-to-deg (/ pi 4))
  ;; => 45
  ;;
  ;; The function RAD-TO-DEG is applied as an example, in this instance,
  ;; considering the common practice of denoting degree type phase 
  ;; angles within methodologies of electrical circuit analysis onto
  ;; inductive, capacitive, and resistive circuits with AC electrical
  ;; components -- although Common Lisp uses radians, canonically.
  ;; 
  
  
  ;; %% LOG
  
  (defop 'log :variadic-p nil)
  
  ;;; % Overloading for Other Monadic Functions
  
  