anchor.diff:  
   
   (defclass* measurement ()
  -    ((magnitude real :initform 0)
  -     ;; degree : an exponent of 10
  -     (degree fixnum :initform 0)))
  -
  -(defun base-magnitude (m)
  +  ;; magnitude : a real value that, when multplied by 10^degree,
  +  ;; then serves as an effective element for calculating the
  +  ;; `scalar-magnitude' for the measurement
  +  ((magnitude real :initform 0)
  +   ;; degree : an exponent of 10, denoting the degree of the decimal
  +   ;; prefix factor for the measurement; serves as like a scale
  +   ;; value. see also: PREFIX class and protocol
  +   ;;
  +   ;; TO DO: For measures of information content (byte, etc) define an 
  +   ;; additional prefix system - onto powers of 8, rather than of 10.
  +   ;; The DEGREE slot for MEASUREMENT may be interpreted in simply an
  +   ;; alternate regards, then -- as in (expt 8 DEGREE) rather than 
  +   ;; (expt 10 DEGREE) -- respectively, an effective FACTOR-BASE of 8
  +   ;; rather than 10
  +   (degree fixnum :initform 0)
  +   ;; FIXME: For purpose of memoization, consider developing a
  +   ;; MEMOIZED-SLOT protocol such that a slot
  +   ;; MEMOIZED-FACTORED-MAGNITUDE would store an effective 
  +   ;; cached value of (* magnitude (expt factor-base degree)) 
  +   ;; Referencing Garnet KR, the same slot may be defined effetively
  +   ;; with a formula onto other slots in the class and other formulas
  +   ;; iin the Lisp environment
  +   ))
  +
  +
  +;; FIXME: Move this DEFCONSTANT into prefix handling code, and consider
  +;; refactoring this system for defining an accessor FACTOR-BASE onto a
  +;; new class PREFIX-CLASS - such that would allow for defining
  +;; prefixes for an octal factor base, as for measurements of data
  +;; quantities within information systems
  +(eval-when (:compile-toplevel :load-toplevel :execute)
  +  (defconstant %factor-base% 10)
  +  )
  +
  +(defun base-magnitude (m)  
  +  "Calculate the scalar magnitude of the measurement M for the base
  +measurement unit of M"
  +  ;;
  +  ;; NB. This function implements a numeric conversion on
  +  ;; a basis of of prefix magnitude. Conversions per ratios of derived
  +  ;; units must be implemneted seperately.
     (declare (type measurement m)
              (values real))
     (let ((deg (measurement-degree m)))
       (cond 
         ((zerop deg) (measurement-magnitude m))
         (t (* (measurement-magnitude m)
  -            (expt 10 deg))))))
  -
  -(defgeneric magnitude-for-degree (measurement degree)
  -  (:method ((m measurement) (deg fixnum))
  -    (let ((next-deg (+ deg (measurement-degree m))))
  -      (cond
  -        ((zerop next-deg) (measurement-magnitude m))
  -        (t (* (measurement-magnitude m)
  -              (expt 10 next-deg)))))))
  -
  -;; (magnitude-for-degree (make-measurement 1 :m 3) 0)
  +            (expt #.%factor-base% deg))))))
  +
  +;; (base-magnitude (make-measurement 1 :m 3))
   ;; => 1000
   
  -;; (magnitude-for-degree (make-measurement 1 :m 3) -3)
  -;; => 1
  -
  -
  -;;; % Prefix Notation 
  -
  -;; NB: "Engineering notation" typically uses only prefixes for degrees
  -;; in multiples of 3
  -
  -(defgeneric prefix-degree (instance))
  -(defgeneric prefix-print-label (instance))
  -(defgeneric prefix-print-name (instance))
  -(defgeneric prefix-symbol (instance))
  -
  -
  -(deftype prefix-degree ()
  -  '(integer -24 24))
  -
  -(defclass* prefix ()
  -  ((degree prefix-degree)
  -   (print-label simple-string)
  -   (print-name simple-string)
  -   (symbol symbol)))
  -
  -
  -(defmethod print-object ((instance prefix) stream)
  -  (print-unreadable-object (instance stream :type t :identity t)
  -    (princ (slot-value* instance 'print-label) stream)))
  -
  -  (define-condition entity-not-found (error)
  -  ((name
  -    :initarg :name
  -    :reader entity-not-found-name)))
  -  
  -
  -(define-condition prefix-not-found (entity-not-found)
  -  ()
  -  (:report
  -   (lambda (c s)
  -     (format s "No measureent prefix registered for name ~S"
  -             (entity-not-found-name c)))))
  -
  -(define-condition prefix-degree-not-found (entity-not-found)
  -  ()
  -  (:report
  -   (lambda (c s)
  -     (format s "No measureent prefix registered for degree ~S"
  -             (entity-not-found-name c)))))
  -
  -
  -(declaim (type simple-vector %prefixes%))
  -(defvar %prefixes% (make-array 22))
  -
  -
  -(defun find-prefix (s)
  -  (declare (type symbol s)
  -           (values prefix))
  -  (or (find s %prefixes%
  -            :test #'eq
  -            :key #'measurement-symbol)
  -      (error 'prefix-not-found :name s)))
  -
  -
  -;; define prefix classes
  -(let ((n -1))
  -  (labels ((do-def (p degree print-name name)
  -             (let ((p (make-instance 'prefix
  -                                     :symbol name
  -                                     :degree degree
  -                                     :print-name print-name
  -                                     :print-label (string-downcase (symbol-name p))
  -                                     )))
  -               (setf (svref %prefixes% (incf n)) p)
  -               (values p))))
  -    (mapcar (lambda (spec)
  -              (destructuring-bind 
  -                    (c  degree print-name name) spec
  -                (do-def c degree print-name name)))
  -          '((yotta 24 "Y" :|Y|)
  -            (zetta 21 "Z" :|Z|)
  -            (exa 18 "E" :|e|)
  -            (peta  15 "P" :|p|)
  -            (tera  15 "T" :|t|)
  -            (giga  9 "G" :|g|)
  -            (mega  6 "M" :|M|)
  -            (kilo  3 "k" :|k|)
  -            (hecto  2 "h" :|h|)
  -            (deca  1 "da" :|da|)
  -            (deci  -1 "d" :|d|)
  -            (centi  -2 "c" :|c|)
  -            (milli  -3 "m" :|m|)
  -            (micro  -6 "μ" :|u|)
  -            (nano  -9 "n" :|n|)
  -            (pico  -12 "p" :|p|)
  -            (femto  -15 "f" :|f|)
  -            (atto  -18 "a" :|a|)
  -            (zepto  -21 "z" :|z|)
  -            (yocto  -24 "y" :|y|)))))
  -
  -
  -
  -
  -;; FIXME: does not work in SBCL, but probably should.
  -;;
  -;; In macroexapansion for DEFBOUNCE%, NAME is said to be unbound
  -;;
  -;; something about the walker hopping over a binding??
  -
  -;; - https://bugs.launchpad.net/sbcl/+bug/1368847
  -;;
  -;; so, must define the methods, each, manually
  -#+NIL
  -(labels ((defbounce (sl)
  -           (let ((name 
  -                  (intern-formatted "~A~A" 
  -                                    (quote #:measurement-)
  -                                    (slot-definition-name sl))))
  -             (macrolet ((defbounce% ()
  -                          `(defmethod ,name ((instance measurement))
  -                             (,name (class-of instance)))))
  -               (defbounce%)))))
  -  
  -  ;; for direct slots in MEASUREMENT-CLASS, define accessors onto
  -  ;; MEASUREMENT to access the respective slot of the same class
  -  (dolist (sl (class-direct-slots 
  -               (find-class 'measurement-domain)))
  -    (defbounce sl)))
  +;; (base-magnitude (make-measurement 1 :m -3))
  +;; => 1/1000
  +
  +(defgeneric scalar-magnitude (scalar)
  +  (:method ((scalar measurement))
  +    (base-magnitude scalar)))
  +
  +;; (scalar-magnitude (make-measurement 1 :m -3))
  +;; => 1/1000
  +
  +
  +;;; % MEASUREMENT
   
   (defmethod measurement-quantity-name ((instance measurement))
     (measurement-quantity-name (class-of instance)))
  
positive.code: 
  (in-package #:cl-user)
  
  (eval-when (:compile-toplevel :load-toplevel :execute)
  
  
negative.code: (defmacro defclass* (name-form (&rest superclasses) 
                               (&rest slot-definitions)
                       &rest initargs)
    ;; FIXME: This macro does not, of itself, provide a complete
    ;; "DEFCLASS* SOMEWHAT LIKE DEFSTRUCT"  implementation. Features
    ;; presently lacking of this implementation, in that regards
    ;; may include:
    ;; 
    ;; * Many of the features avaialble for structure classes defined
    ;;   via DEFSTRUCT are altogether lacking from this protocol, such
    ;;   as: 
    ;;    * Naming and definition of a <type-p> predicate function
    ;;    * Naming and definition of a <copier> function
    ;;    * Specification of an object printer function
    ;;    * Naming and lambda list syntax for constructor functions
    ;;    * Nothing such as DEFSTRUCT's linear :INHERIT
    ;;    * Nothing such as a list type or vector type syntax for instances
    ;;    * Other qualities, as denoted in the following
    ;;
    ;; * In that this DEFCLASS* macro implements a syntax "Somewhat like
    ;;   defstruct", the following features are noted:
    ;;
    ;;   * NAME-FORM may be a symbol or a list. If a symbol, then
    ;;     NAME-FORM denotes the name of the class. If a list, then
    ;;     NAME-FORM denotes -- as its first element -- the name of the
    ;;     class, with a syntax similar to DEFTTRUCT <name-and-options>.
    ;;    
    ;;     DEFCLASS* emulates DEFSTRUCT' :CONC-NAME option
    ;;
    ;;   * For all direct slots of the class, a set of reader and writer
    ;;     methods will be defined, as named according to CONC-NAME
    ;;     interpreted in a manner similar to as with DEFSTRUCT (FIXME:
    ;;     However, in its present revisin, DEFCLASS* rather interprets
    ;;     a NULL CONC-NAME as a "flag" that no reader or writer methods
    ;;     should be defined). Unless the slot-definition is denoted as
    ;;     :READ-ONLY, a writer method will be defined for the slot
    ;;     definition, named as per <that naming convention>. In <all
    ;;     instances>, a reader method will be defined for the slot
    ;;     instances>definition (NOTE: Unless CONC-NAME is NULL
  
    ; FIXME: Redefine DEFCLASS* to interpret CONC-NAME in a manner more
    ; consissent onto DEFSTRUCT; provide an additional slot definition
    ; "flag" value for denoting if a slot defintion is not to have any
    ; reader or writer methods defined for it; revise this
    ; documentation, subsequent to that changeset. (Firstly, move
    ; DEFCLASS* into the mci-cltl-utils source tree). Lastly, describe
    ; the complete syntax for slot definition specifiers, as implemented
    ; of this DEFCLASS* macro -- and make a more direct reference to the
    ; X3J13 discussions surrounding the definition of the syntax of each
    ; of DEFSTRUCT and DEFCLASS in CLtL2 -- all of this, to proceed
    ; after implementation of Jetbrains' YouTrack and TeamCity
    ; components into a Glasfish server in an AWS instance.
  
    ;;
    ;; * When a class' slot is redefined from "not read only" to "read
    ;;   only" then the SLOT-DEFINITION-WRITER methods defined for slots
    ;;   in the class as side-effects of its definition as "not read
    ;;   only" are not undefined. Those "then invalid" writer methods
    ;;   should be made undefined, however, as consequent with the
    ;;   change in slot definition qualities
    ;;
    ;; * Concerning the :READ-ONLY value for slot specifiers for this
    ;;   macro, presently that value may seem to represent something of
    ;;   a misnomer. <Presently> :
    ;;
    ;;     * The READ-ONLY value is not stored with the slot
    ;;       definition - whether its direct slot definition of
    ;;       effective slot defintion
    ;;
    ;;     * The READ-ONLY value will not be inherited by subclasses
    ;;
    ;;     * The READ-ONLY value does not actually prevent SETF access
    ;;       to slots, as by way of (SETF SLOT-VALUE)
    ;;
    ;;   Those shortcomings may be addressed, subsequently, with a
    ;;   definition of a READ-ONLY-INSTANCE-SLOT-DEFINITION
    ;;   protocol. However, as one's experiences in developing
    ;;   extensions onto CLOS might seem to prove: Once the proverbial
    ;;   Pandora's box of slot definition extension is opened, then --
    ;;   in less figurative terms -- it may be difficult to develop any
    ;;   effectively "layered" extensions onto STANDARD-SLOT-DEFINITION,
    ;;   as well as the direct and effective slot definition subclasses
    ;;   of STANDARD-SLOT-DEFINITION. Certainly, that is not to
    ;;   criticise the design of MOP, whereas -- presently -- one
    ;;   considers that it may be possible to develop an extensional
    ;;   architecture for facilitating a definition of "layered",
    ;;   domain-specific slot definition extensions
    ;;
    ;;   As well as that such an architecture may be applied in
    ;;   developing this READ-ONLY-INSTANCE-SLOT-DEFINITION proposal,
    ;;   but furthtermore: Such an architecture may be applied for
    ;;   developing a MODALLY-LOCKED-SLOT-DEFINITION protocol namely
    ;;   using read-write locking onto slot values, as may be
    ;;   facilitative of thread safety in Common Lisp programs.
    ;;
    ;;   Thirdly, such an architecture may be applied for developing an
    ;;   L10N-SLOT-DEFINITION proposal, namely to facilitate
    ;;   internationalization of locale-specific values - especially,
    ;;   language-specific strings -- within Common Lisp applications.
    ;;   See also: The #I18N notes peppered throughout the codebases
    ;;   provided of the MetaCommunity.info project
    ;;
    ;;  Thus, effectively five "Architectural FIXME" items are defined here:
    ;;
    ;;  * DEFCLASS*-MORE-SOMEWHAT-LIKE-DEFSTRUCT
    ;;  * LAYRED-SLOT-DEFINITON-ARCHITECTURE
    ;;  * READ-ONLY-SLOT-DEFINITION
    ;;  * MODALLY-LOCKED-SLOT-DEFINITION
    ;;  * L10N-SLOT-DEFINITION liketly to be followed with
    ;;    I18N-STRING-SLOT-DEFINITION and a broader I18N protocol
    ;;    integrating with existing internationalization frameworks, e.g
    ;;    "PO files"
    (destructuring-bind (name &key (conc-name nil cnp))
        (cond
          ((symbolp name-form) (list name-form))
  