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:   (:symbol . :|N|)
    (:metaclass compound-measurement-class)
    (:expression :|m| :|kg| (:|s| -2))
    (:documentation "Measurement class for quantities \
  of force in base unit newton (N)
  
  Symbolic representation: :N"))
  
  #+NIL ;; instance test
  (measurement-domain-base-measure (find-class 'force))
  ;; => #<COMPOUND-MEASUREMENT-CLASS NEWTON>
  
  #+PROTOTYPE
  (register-measurement-class 'newton)
  
  #+PROTOTYPE
  (resister-compound-measurement-class 'newton)
  
  ;; (measurement-unit-sequence (find-class 'newton))
  ;; => #(#<LENGTH METER> #<MASS KILOGRAM> #<TIME SECOND>)
  
  ;; (measurement-degree-sequence (find-class 'newton))
  ;; => #(1 1 -2)
  
  ;; (measurement-normalized-expression (find-class 'newton))
  ;; => #2A((#<LENGTH METER> 1) (#<MASS KILOGRAM> 1) (#<TIME SECOND> -2))
  
  (defclass compound-unit-expr (unit-expr)
    ((elements
      :initarg :elements
      :accessor unit-expr-elements
      :type (simple-array t (* 2)))))
  
  
  ;; NORMALIZE-UNIT - Prototype
  
  (defun normalize-unit-expression (&rest exprs)
    (declare (values (simple-array t (* 2))))
    (let* ((%exprs (coerce exprs 'simple-vector))
           (n (length %exprs))
           (buffer (make-array n :fill-pointer 0)))
      (declare (type simple-vector %exprs))
      (dotimes (index n (make-array (list (length buffer) 2)
                                    :initial-contents buffer))
        (let* ((elt (aref %exprs index))
               (s (etypecase elt
                    (symbol elt)
                    (cons (car elt))))
               (c (find-measurement-class s))
               (d (etypecase elt
                    (symbol 1)
                    (cons (cadr elt)))))
          (declare (type measurement-class c)
                   (type fixnum d))
          (flet ((add-elt (c d buffer)
                   ;; FIXME: CONSY buffer implementation
                   (vector-push-extend (list (measurement-symbol c) d) 
                                       buffer)))
          (etypecase c
            ((or base-measurement-class 
                 linear-measurement-class
                 geometric-measurement-class)
             (add-elt c d buffer))
            (compound-measurement-class
             (let ((nex (measurement-normalized-expression c)))
               (dotimes (%index (array-dimension nex 0))
                 (let ((%c (aref nex %index 0))
                       (%d (* d (aref nex %index 1))))
                   (add-elt %c %d buffer)))))))))))
  
  ;; NORMALIZE-UNIT / SIMPLIFY-UNIT - Usage cases
  
  ;; Prototype: Newtonian force / Weight / Acceleration due to gravity (Units)
  ;;
  ;; (normalize-unit-expression :|N|)
  ;; => #2A((:|m| 1) (:|kg| 1) (:|s| -2))
  ;;
  ;; (normalize-unit-expression :|m| :|kg| '(:|s| -2))
  ;; => #2A((:|m| 1) (:|kg| 1) (:|s| -2))
  
  ;; (simplify-unit-expression :|m| :|kg| '(:|s| -2))
  
  ;; Prototype: Momentum (Units)
  ;;
  ;; (normalize-unit-expression :|N| :|s|)
  ;; (simplify-unit :|m| :|kg| (:|s| -2) :|s|)
  ;; (simplify-unit :|kg| :|m| (:|s| -1))
  