anchor.diff:  
   (defgeneric class-prototype-metaclass (class)
     (:method ((class singleton))
  +    ;; FIXME - Handle specially when CLASS would be the PROTOTYPE-CLASS class
  +    ;; itself, as within ENSURE-PROTOTYPE-METACLASS
       (find-class 'prototype-class))
  +
     #+NIL
     (:method ((class standard-class))
       ;; NB: STANDARD-CLASS would not support an :IMPLEMENTATION-CLASS
  
positive.code: 
  (defgeneric ensure-prototype-metaclass (proto use-metaclass for-class
                                          direct-superclasses)
    (:method ((proto prototype-class) (use-metaclass standard-class)
              (for-class singleton)
              (direct-superclasses list))
      (declare (ignore use-metaclass for-class direct-superclasses))
      ;; FIXME - DO NOT IGNORE PARAMS - VERIFY PROTO onto those parameters
      (values proto))
  
  
    (:method ((proto null) (use-metaclass standard-class)
              (for-class singleton)
              (direct-superclasses list))
      (error "Erroneous prototype metaclass name for ~s: ~s" proto
             for-class))
  
  
  
negative.code:             (direct-superclasses list))
  
      (or (find-class proto nil) ;; NB - CLASS REUSE
          ;; FIXME - only reuse the class when it conforms to the
          ;; following implementation pattern - else generate a new
          ;; prototype class name and dispatch to the following
  
          (labels ((sort-classes (proto-meta for-c use-meta direct-supers)
                     (list* proto-meta for-c use-meta
                            (remove proto-meta
                                    (remove use-meta
                                            (remove for-c direct-supers
                                                    :test #'eq)
                                            :test #'eq)
                                    :test #'eq))))
            (let ((proto-metaclass (class-prototype-metaclass for-class))
                  (%direct-superclasses
                   ;; TBD - wrap the COMPUTE-CLASS call with something to
                   ;; signal a FORWARD-REFERENCED-SUPRECLASS error
                   ;; onto FOR-CLASS, for any forward-referenced class
                   ;; in direct-superclasses
                   (mapcar #'compute-class direct-superclasses)))
              (ensure-class proto
                            :metaclass  proto-metaclass
                            :name proto
  
                            :direct-superclasses
                            ;; FIXME : Trivial superclass sorting
                            (sort-classes proto-metaclass
                                          for-class
                                          use-metaclass
                                          %direct-superclasses)
  
                            :implementation-class for-class))))))
  
  
  (defgeneric ensure-prototype-metaclass-name (for-metaclass class-name)
  