anchor.diff:  ;; ...
   
     (defsingleton* x-b (x-a)
  -    ;; FIXME: New DEFSINGLETON* DNW for any forward-referenced superclass
  +    ;; NB: PCL will err here iff x-a is a forward referenced class
       ())
   
     (typep (make-instance 'x-b) 'x-b)
  
positive.code:   ((sl-c)))
  
  
  (class-slots (find-class 'singleton-1-2))
  
  (class-direct-slots (find-class 'singleton-1-2))
  
  (typep (find-class 'singleton-1-1) 'singleton-1-1)
  ;; => NIL ; which still is not good for this design
  
negative.code:                              ,%supers)
                   (setf ,%supers (nconc ,%supers (list ,%singleton)))))
  
               ;; NB: This macro, in effect, prevents any usage of forward
               ;; referenced classes in the SUPERCLASSES list
  
               ;; AS SUCH, MACROLET might be useful within this
               ;; macroexpansion - to ensure that an appropriate direct
               ;; superclasses list can be computed, consistently,
               ;; for each of the ,%PROTO-NAME and ,%NAME classes
               ;;
               ;; Note that as this already requires that none of the
               ;; SUPERCLASSES will be a FORWARD-REFERENCED-CLASS,
               ;; it can therefore be determined - reliably - whether any
               ;; of a SINGLETON or PROTOTYPE-CLASS metaclass is denoted
               ;; in the SUPERCLASSES list for - respectively - the ,NAME
               ;; and ,%PROTO-NAME classes
  
               (defclass ,%proto-name (,@%user-metaclass prototype-class
                                                         ,@superclasses)
                 ()
                 (:metaclass prototype-class))
  
               (defclass ,name
                    ;; NOTES - SINGLETON AS DIRECT SUPERCLASS (A HACK)
                    ;; does not break, but does not result in an
                    ;; appropriate class precedence list (w/ PCL)
                    #+NIL (,@superclasses)
                    ;; breaks when defining subclasses, does not break at first
                    #+NIL (singleton ,@superclasses)
                    ;; does not break, and may result in an appropriate class
                    ;; precedence list in the class
                    ;;
                    ;; FIXME -  MIGHT BREAK under some superclasses having
                    ;; SINGLETON as a superclass (More test cases req'd)
                    (,@superclasses singleton)
                  ,slots
                  (:metaclass ,%proto-name)
                  ,@%params)))))))
  
  
  ;; FIXME: Test DEFSINGLETON* with forward-referenced direct superclasses
  
  