anchor.diff:    (subtypep (make-instance 'x-b) 'x-a)
     ;; FIXME while => NIL, T
   
  +  (subtypep (class-of (make-instance 'x-b)) 'x-a)
  +  ;; => T, T
  +  ;; consistent onto CLOS
  +  ;;
  +  ;; approximately equivalent:
     (subtypep (find-class 'x-b) 'x-a)
     ;; => T, T
  -  ;; should be same, with or without the added SHARED-INITIALIZE
  -  ;; as it's consistent onto CLOS
  +  ;; consistent onto CLOS
   
   
   ;; -- test the new SHARED-INITIALIZE method with the original DEFSINGLETON macro
  
positive.code:   ;;     meachanisms by which STANDARD-CLASS was defined in a manner as
    ;;     to represent an instance of itself, in any implementation.
  
    (labels ((compute-user-metaclass (params)
               (let ((meta-n (position :metaclass
                                       (the list params)
  
negative.code:                                 &rest initargs &key
                                                   direct-superclasses
                                                   &allow-other-keys)
  
    ;; NB: This method serves to ensure that SINGLETON should appear in
    ;; the class precedence list for INSTANCE. If none of the
    ;; direct-superclasses is a subclass of SINGLETON, the class SINGLETON
    ;; will be added to the head of the direct superclasses list.  This
    ;; method also serve to ensure that any instance of the class
    ;; STANDARD-OBJECT is removed from the initial direct superclasses
    ;; list.
  
    ;; NB: In some call sequences -- such as when a singleton is created
    ;; initially from DEFCLASS, rather than CHANGE-CLASS from a
    ;; FORWARD-RERFERENCED-CLASS -- this may be "Early enough" to catch
    ;; where PCL is initially setting the direct-superclasses list for the
    ;; class definition.  NB: See also CHANGE-CLASS, SHARED-INITIALIZE
  
  
    ;; FIXME: Also ensure that any call to MAKE-INSTANCE of a SINGLETON
    ;; will produce an object that is a subtype of the original
    ;; SINGLETON. This may be approached, somewhat portably, with
    ;; ALLOCATE-INSTANCE. Such a methodology  may serve to require
    ;; that a new  class will be initialized within some calls to
    ;; ALLOCATE-INSTANCE - rather than within a top-level DEFCLASS form,
    ;; such that would be processed by the implementation compiler.
    ;;
    ;; In such a methodology, there may be an effect produced such that
    ;; the class of a SINGLETON created with MAKE-INSTANCE would a
    ;; subclass of, but not equivalent to the class provided to
    ;; MAKE-INSTANCE
    ;;
    ;; To an effect
    ;;   (subtypep (make-instance the-singleton) the-singleton) => T, T
    ;;
  
    (let ((tgt-class (find-class 'singleton))
          (unused-class (find-class 'standard-object))
  