anchor.diff:                  (getf initargs :degree-sequence) (map-degrees nex))))
         (cond 
           (args-changed-p (apply #'call-next-method instance slots initargs))
  +        ;; FIXME: Thie following CALL-NEXT-METHOD form should probably
  +        ;; not be denoted as 'unreachable code' by the compiler.
  +        ;; In SBCL 1.2.5.76-65a44db, it is denoted as unreachable
  +        ;; however. 
           (t (call-next-method))))))
   
   ;; To Do: Develop prototypes for SIMPLIFY-UNIT / NORMALIZE-UNIT
  
positive.code:   (:metaclass measurement-domain)
    (:base-measure . newton))
  
  
  #+PROTOTYPE
  (defclass newton (measurement)
  
negative.code: 
  (in-package #:math)
  
  #+NIL
  (defconstant* +si-base-measurement-metaclasses+ ;; (?)
      ;; This constant value is defined here, in order to ensure that
      ;; all of the base measurement unit classes are defined at the
      ;; time when this form is evaluated
      (make-array 7
                  :initial-contents
                  (mapcar #'find-class
                          '(base-length 
                            base-mass 
                            base-time 
                            base-electrical-current
                            base-temperature 
                            base-amount-substance
                            base-luminous-intensity))))
  
  (defgeneric measurement-unit-sequence (class))
  
  (defgeneric measurement-degree-sequence (class))
  
  (defgeneric measurement-normalized-expression (class))
  
  
  ;; % Compound Measurements - Registry and Retrieval
  
  #| Notes
  
  * This system will define a registry specifically for compound
    measurement unit classes, effectively augmenting the registry of
    base and derived measurement unit classes  comprised of
    `%MEASUREMENT-CLASSES%' and its corresponding
    `%MEASUREMENT-CLASSES-LOCK%'
  
  * At time of registering a componound measurement class, the class may
    be indexed within the compound measurement unit classes registry,
    according to three primary values:
  
      0. The identity of the class, itself. Assuming that the Common
         Lisp implementation ensures that any class Cn named N (n > 1)
         will always be EQ to class C1 named N, the identity of the
         class Cn may be applied as an index key, such that the
         functions storing and accessing the index may use EQ
         as a :test function.
  
      1. The MEASUREMENT-NORMALIZED-EXPRESSION defined to the
         measurement unit class. Although this may seem to denote a 
         cosmetically appealing method for functional query onto the
         compound measurement unit classes registry, however it may not
         present the most optimal approach possible.
  
      2. The set of the unit sequence and degree sequence for the
         normalized measurement unit expression defined to
         the measurement unit class. It may serve to permit for an
         optimized implementation in the functions for measurement query
         and unit conversion, when these values would be accessed
         seperately.
  
  * When searching for a measurement unit class, provided an arbitrary
    "normalized" base measurement unit expression, it may be assumed:
  
      * that the elements of the expresion may occur in any arbitrary 
        order. 
      * that a subset of the elements of the expression may effectively
        "match" the complete set of elements of a registered, compound
        measurement unit class
      * that the expression may contain elements in addition to any
        subset of elements effectively "matching" the normalized unit
        expression of any registered, compound measurement unit class
  
  |#
  
  ;; % Compound Measurements - Measurement Class Definition and Initialization
  
  
  (defclass compound-measurement-class (measurement-class)
    ((unit-sequence
      :initarg :unit-sequence
      :type (simple-array measurement-class (*))
      :reader measurement-unit-sequence)
     (degree-sequence
      :initarg :degree-sequence
      :type (simple-array fixnum (*))
      :reader measurement-degree-sequence)
     (normalized-expression
      :type (simple-array t (* 2))
      :initarg :normalized-expression
      :reader measurement-normalized-expression
      )))
    
  
  