anchor.diff:  	  ;; With OP declared incline, however, maybe it would be
   	  ;; possible for the compiler to further optimize the following
   	  ;; form.
  +	  ;; FIXME: #I18N
  +	  (require-diadic "Cannot define DEFAULT diadic method for DEFOP with :DIADIC-P NIL")
   	  (let ((%c (compute-class default)))
   	    (makem gf-diadic op (list %c %c) '(a b)
   		   `(funcall (function ,op) a b))))
   
   	(cond
   	  (variadic-p
  +	   ;; FIXME: #I18N
  +	   (require-diadic "VARIADIC-P specified for DEFOP with :DIADIC-P NIL")
  +	   (require-monadic "VAIRADIC-P specified for DEFOP with :MONADIC-P NIL")
   	   ;; Define a variadic function.
   	   ;;
   	   ;; FIXME: This produces a generic function that canot be
  
positive.code:                                                `(type ,(class-name c) ,arg))
                                             ll specializers)))
                    ,form))
  
  	     (ensure-gfn (name lambda &optional (prec lambda))
  	       (ensure-generic-function 
  
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
  
  