anchor.diff:  ;;; looks the same, but with a different name and then we transfer the
   ;;; class and slots from the fake class to the bare standard-instance.
   
  -(defclass fake (slot-definition)
  +(defclass fake (standard-slot-definition direct-slot-definition)
     #.*direct-slots-standard-direct-slot-definition*)
   
   (let ((to-patch (find-class 'standard-direct-slot-definition))
  
positive.code: ;;; but in no particular order.  We must be careful here, in that we
  ;;; might have to handle an incorrect inheritance graph, that might
  ;;; contain circular dependencies.
  ;; (defun find-all-superclasses (class)
  ;;   (let ((result '()))
  ;;     (labels ((find-all-supers (class)
  ;; 	       (unless (member class all-supers :test #'eq)
  ;; 		 (push class all-supers)
  ;; 		 (loop for super in (class-direct-superclasses class)
  ;; 		       do (find-all-supers super)))))
  ;;       (find-all-supers class))
  ;;     result))
  
  ;;; For a given class, compute a precedence relation.  
  ;;; This relation is represented as a list of cons cells, 
  
negative.code: ;;; DESCRIBE and PRINT
  
  (defun print-object (object stream)
    (cond (;; Temporary solution until we can actually print class T.
  	 (eq object (find-class t))
  	 (format stream
  		 "<SICL-BUILTIN-CLASS SICL-T>"))
  	((classp object)
  	 (format stream
  		 "<SICL-~s SICL-~s>"
  		 (class-name (standard-instance-class object))
  		 (class-name object)))
  	((standard-instance-p object)
  	 (format stream
  		 "<SICL-~s>"
  		 (class-name (standard-instance-class object))))
  	(t
  	 (cl:print-object object stream))))
  
  (cl:defmethod cl:print-object ((object standard-instance) stream)
    (print-object object stream))
  