anchor.diff:                    (values 'singleton params))))))
       (let ((%proto-name
              ;; FIXME: Allow this to be specified in PARAMS (??)
  +           ;; FIXME: Also provide the class, itself, as the value of
  +           ;;        a :singleton-prototype initarg or
  +           ;;        SINGLETON-PROTOTYPE access for the resulting
  +           ;;        class named NAME - such that would serve to
  +           ;;        differentiate the automatically created prototype
  +           ;;        class from the list of user-specified direct
  +           ;;        superclasses
              (make-symbol (concatenate 'simple-string
                                       (symbol-name name)
                                       (symbol-name '#:-prototype)))))
  
positive.code:                                           :direct-superclasses ,%supers)))
                 ;; NB: ^ This may not be sufficent as to be able to
                 ;; locate the class during evaluation of the following
                 (values
                  (defclass ,name ,(cons %proto-name superclasses)
                    ,slots
                    (:metaclass ,%proto-name)
                    ,@%params)
                  ,%proto
                  ,%fwd))))))))
  
  (eval-when ()
  
  
negative.code:   (defclass f-3 (f-2)
      ())
  
    (find-class-in-precedence 'f-1 'f-1)
    => #.(find-class 'f-1)
  
    (find-class-in-precedence 'f-1 'f-3)
    => #.(find-class 'f-2)
  
    (find-class-in-precedence 'g-1 'f-3 nil)
    => no value returned
  
    (defclass g-2 () ())
  
    (find-class-in-precedence 'g-2 'f-3 nil)
    => no value returned
  )
  
  ;; FIXME: use (FIND-CLASS-IN-PRECEDENCE 'singleton ...) in DEFSINGLETON*
  
  
  ;; NB
  ;; (typep (find-class 'standard-class) 'standard-class)
  ;; => T
  
  (defclass singleton* (singleton)
    ((%prototype-metaclass
      ;; should be EQ to the class itself
      ;; ... at least in any subclass
      :initarg :%prototype-metaclass
      :type class
      ))
    (:metaclass singleton))
  
  
  (defmacro getf* (place property &optional default)
    ;; FIXME - move definition to ltp-common
    (with-symbols (dflt obj)
      `(let* ((,dflt (load-time-value (make-symbol
                                       #.(symbol-name (quote :%default)))
                                      t))
              (,obj (getf ,place ,property ,dflt)))
         (declare (dynamic-extent ,dflt))
         (cond
           ((eq ,obj ,dflt)
            (values ,default nil))
           (t
            (values ,obj t))))))
  
  
  #+NIL
  (defmethod allocate-instance ((class singleton*)
                                &rest initargs)
    ;; Prototype (Unused)
    ;;
    ;; NB: MAKE-INSTANCE <CLASS> considered contradictory, if it cannot be
    ;; portably accompanied with any form to ensure that the compiler will
    ;; recognize the instance as both a type and a class.
  
    (let (initargs-updated)
      (macrolet ((dispatch
                     `(cond
                        (initargs-updated
                         (apply #'call-next-method class initargs))
                        (t (call-next-method)))))
        (multiple-value-bind (metaclass mc-p)
            (getf* initargs :metaclass)
          (declare (ignore metaclass))
          (unless mc-p
            (prog1 (setf (getf initargs :metaclass)
                         (make-instance ... ;; NOPE
                                        ))
              (setq initargs-updated t))))
      (dispatch))))
  
  
  
  #+NIL
  (defmethod shared-initialize ((instance singleton*) slots
                                &rest initargs
                                  &key (prototype-class nil pm-p)
                                    &allow-other-keys)
    ;; NB: The PROTOTYPE-CLASS should be the class of the INSTANCE itself
    )
  
  
  
  
  (defmacro defsingleton* (name (&rest superclasses)
                                  slots
                           &rest params)
    ;; FIXME - due to the convention of always creating a new, compiler-
    ;;         unregistered prototype-class, as approched in this updated
    ;;         defsingleton macro -- in its present revision -- this macro
    ;;         cannot be evaluated twice for the same class.
  
    ;; NB: As one purpose that this new DEFSINGLETON* serves, juxtaposed
    ;;     to the original DEFSINGLETON definition: This macro definition
    ;;     serves to ensure -- at least insofar as to a perspective of
    ;;     instance/superclass and metaclass relations in CLOS -- that the
    ;;     resulting SINGLETON instance will be (FIXME: Shouild be) at
    ;;     least a subtype (in such a regard) to every class specified in
    ;;     SUPERCLASSES.
    ;;
    ;;     ----
    ;;     FIXME: As this presently uses ENSURE-CLASS to create a
    ;;     metaclass -- in a phrase, a PROTYPE-CLASS for the resulting
    ;;     SINGLETON -- such that, in that effect, may not be registered
    ;;     to the implementation type system in such a way as might be
    ;;     approached via DEFCLASS ... this system may presently lend
    ;;     to some spurious results, in testing forms.
    ;;     ----
    ;;     Subsequently, this should be updated to use DEFCLASS to define
    ;;     the PROTOTYPE-CLASS as a class named either according to a
    ;;     default naming convention local to this macro definigion, or
    ;;     defined with a user-specified :PROTYPE-METACLASS name. This
    ;;     macro definition may also be updated to include any
    ;;     user-specified :METACLASS in the class precedence list of the
    ;;     resulting PROTOTYPE-CLASS -- to an effect, the resulting CLASS
    ;;     will at least be TYPEP onto the user-specified METACLASS, even
    ;;     if the resulting CLASS will not be an instance of that
    ;;     METACLASS itself.
    ;;     ----
    ;;     NB: This documentation, in effect, uses the term PROTOTYPE-CLASS in
    ;;     lieu of METACLASS as it denotes -- in the former -- a class
    ;;     defined during evaluation of DEFSINGLETON*, however serving
    ;;     in a role of a conventional CLOS metaclass.
    ;;     ---
    ;;
    ;;     Considering limitations extended of MOP implementations, it
    ;;     may be impossible to produce a portable definition of a class
    ;;     such that will be TYPEP of its own class, anywhere beyond
    ;;     STANDARD-CLASS.
    ;;
    ;;     After refactoring some of a subtype semantics onto a class'
    ;;     metaclass -- i.e onto the class M of which the class C is
    ;;     itself an instance -- it may be assumed that some additional
    ;;     concerns can be addreessed with regards to typing for SINGLETON
    ;;     instances. In that regard, this macro provides something of an
    ;;     update to the original DEFSINGLETON macro definition.
    ;;
    ;;     This updated DEFSINGLETON* may serve to address some concerns
    ;;     with regards to SINGLETON instance typing, even if this cannot
    ;;     portably emulate the "Metacircular" character of STANDARD-CLASS
    ;;     -- there being, simply, no portable API provided for extending
    ;;     of however that was addressed for STANDARD-CLASS, in each MOP
    ;;     implementation, itself.
  
    (labels ((compute-metaclass (params)
               (let ((meta-n (position :metaclass
                                       (the list params)
  