anchor.diff:  
   ;;; add forward-referenced-class functionality
   
  -(defun forward-referenced-class-p (x) (eq (class-of x) #.(find-class 'forward-referenced-class)))
  -
   (defun not-instantiable-p (class)
       (let ((supers (class-direct-superclasses class)))
  -        (or (find-if #'forward-referenced-class-p supers) (find-if-not #'null (mapcar #'not-instantiable-p supers)))))
  +        (or (find-if #'forward-referenced-class-p supers)
  +             (dolist (class supers) (let ((class (not-instantiable-p class))) (when class (return class)))))))
  +
  +;;; For forward-referenced classes to behave like "identity" elements in a null *lazy-finalize* mode "environment"
  +;;; we should consider the more general case by defining a generic function say, default-direct-superclass.
  +(defmethod compute-class-precedence-list ((class standard-class))
  +    (let ((list (call-next-method)))
  +        (when (forward-referenced-class-p (car (last list))) (push-on-end #.(find-class 'standard-object) list) (push-on-end #.(find-class t) list))
  +        list))
   
   (defmethod finalize-inheritance ((class forward-referenced-class)) (error "Cannot finalize ~a." class))
   
   (defmethod finalize-inheritance :before ((class standard-class))
  -    (when *lazy-finalize* (mapc #'(lambda (x) (unless (finalized-p x) (finalize-inheritance x))) (class-direct-superclasses class))))
  +    (when *lazy-finalize* (mapc #'(lambda (x) (unless (class-finalized-p x) (finalize-inheritance x))) (class-direct-superclasses class))))
   
   (defmethod allocate-instance :before ((class standard-class))
  -    (let ((forward (not-instantiable-p class)))
  -        (when forward (error "Cannot instantiate ~a with an undefined superclass; ~a" class forward)))
  -    (when *lazy-finalize* (unless (finalized-p class) (finalize-inheritance class))))
  +    (if *lazy-finalize*
  +        (unless (class-finalized-p class) (finalize-inheritance class))
  +        (let ((forward (not-instantiable-p class)))
  +            (when forward (cerror "Continue anyway." "Continuable attempt to instantiate ~a with an undefined ~a" class forward)))))
   
   ; redefine
   (defun canonicalize-direct-superclasses (direct-superclasses) `',direct-superclasses)
  
positive.code: (defun (setf slot-definition-allocation) (new-value slot)
  	(setf (getf* slot ':allocation) new-value))
  
  ;;; finalize-inheritance
  
  (defun finalize-inheritance (class) (std-finalize-inheritance class))
  
  (defun std-finalize-inheritance (class) 
    (setf (class-precedence-list class)
          (funcall #'compute-class-precedence-list class))
    (setf (class-effective-slots class)
          (funcall #'compute-slots class))
    (values))
  
  (defun finalized-p (class) (typecase class (standard-class (slot-boundp class 'class-precedence-list))
                                                                     (built-in-class t) (structure-class t)
                                                                     (eql-specializer t) (forward-referenced-class nil)))
  
  (defun has-been-finalized-p (class) (typecase class (standard-class (slot-boundp class 'effective-slots))
                                                                                     (built-in-class t) (structure-class t)
                                                                                     (eql-specializer t) (forward-referenced-class nil)))
  
  (defun update-instance (instance class signature)
      (let* ((local (mapcar #'slot-definition-name (car signature))) (shared (mapcar #'slot-definition-name (cadr signature)))
               (p-slot-value (mapappend #'list (append local shared)
                                                                  (append (coerce (std-instance-slots instance) 'list)
                                                                                (mapcar #'car (coerce (caddr signature) 'list)))))
               (class-effective-slots (class-effective-slots class)) (class-shared-slot-definitions (class-shared-slot-definitions class))
               (class-local (mapcar #'slot-definition-name class-effective-slots))
               (class-shared (mapcar #'slot-definition-name class-shared-slot-definitions)))
          (setf (std-instance-slots instance) (allocate-slot-storage (length class-local) secret-unbound-value))
          (setf (std-instance-signature instance)
                  (list class-effective-slots class-shared-slot-definitions (class-shared-slots class))) ; we'll use setf next
          (dolist (slot class-local)
              (multiple-value-bind (ignore val foundp)
                  (get-properties p-slot-value (list slot)) (declare (ignore ignore)) (and foundp (setf (slot-value instance slot) val))))
          (let ((discarded (set-difference local class-local)))
              (update-instance-for-redefined-class instance
                  (set-difference (set-difference class-local local) shared)
                  (set-difference discarded class-shared)
                  (apply #'append (mapplist #'(lambda (x y)
                                                                    (when (and (member x discarded) (not (eq y secret-unbound-value))) (list x y)))
                                                 p-slot-value))))))
  
  (defun remove-from-deleted-classes (class new-superclasses)
      (mapc #'(lambda (x) (setf (class-direct-subclasses x) (remove class (class-direct-subclasses x))))
  
negative.code: 
  (defun allocate-slot-storage (size initial-value)
  	(make-array size :initial-element initial-value))
  
  ;;; Standard instance slot access
  
  