anchor.diff:  (defclass data-class (standard-class)
     ())
   
  +(defclass data ()
  +  ())
  +
  +(defmethod clone ((object data))
  +  (clone-slots (mapcar 'closer-mop:slot-definition-name (closer-mop:class-slots (class-of object)))
  +               object
  +               (make-instance (class-of object))))
  +
  +(defmethod fset:compare ((first data) (second data))
  +  (labels
  +      ((slot-names (slots)
  +         (mapcar 'closer-mop:slot-definition-name slots))
  +       (compare-slots (slots)
  +         (let ((result :equal))
  +           (dolist (slot slots)
  +             (ecase (fset:compare (slot-value first slot) (slot-value second slot))
  +               (:less
  +                (return-from compare-slots :less))
  +               (:greater
  +                (return-from compare-slots :greater))
  +               (:unequal
  +                (setf result :unequal))
  +               (:equal)))
  +           result)))
  +    (declare (dynamic-extent #'compare-slots #'slot-names))
  +
  +    ;; Same class?  We can compare them!
  +    (when (eq (class-of first) (class-of second))
  +      (return-from fset:compare
  +        (compare-slots (slot-names (closer-mop:class-slots (class-of first))))))
  +
  +    ;; Subtype?  Let's compare what we can!  Subtypes are greater than
  +    ;; supertypes
  +    (when (typep second (type-of first))
  +      (let ((result (compare-slots (slot-names (closer-mop:class-slots (class-of first))))))
  +        (return-from fset:compare
  +          (if (eq :equal result)
  +              :less
  +              result))))
  +
  +    ;; Same as above
  +    (when (typep first (type-of second))
  +      (let ((result (compare-slots (slot-names (closer-mop:class-slots (class-of second))))))
  +        (return-from fset:compare
  +          (if (eq :equal result)
  +              :greater
  +              result))))
  +
  +    ;; Worst case.  Let's compare the slots that we can.  They might
  +    ;; have some common ones.
  +    (let* ((first-slots (slot-names (closer-mop:class-slots (class-of first))))
  +           (second-slots (slot-names (closer-mop:class-slots (class-of second))))
  +           (common-slots (intersection first-slots second-slots))
  +           (result (compare-slots common-slots)))
  +      (return-from fset:compare
  +        (if (eq :equal result)
  +            :unequal
  +            result)))))
  +
  +(defmethod make-load-form ((object data) &optional environment)
  +  (make-load-form-saving-slots
  +   object
  +   :slot-names (mapcar 'closer-mop:slot-definition-name (closer-mop:class-slots (class-of object)))
  +   :environment environment))
  +
   (defmethod closer-mop:validate-superclass ((data-class data-class) superclass)
  -  (if (eq superclass (find-class 'standard-object))
  +  (if (or (eq superclass (find-class 'standard-object))
  +          (eq superclass (find-class 'data)))
         t
         (call-next-method)))
   
  
positive.code:                  ,,set-var)
                `(,',access-macro ,,inner-clone))))))))
  
  (defmacro clone-slots (slots object maker)
    (let ((new (gensym "NEW"))
          (old (gensym "OLD"))
          (slot (gensym "SLOT")))
      `(let ((,new ,maker)
             (,old ,object))
         (dolist (,slot ',slots)
           (setf (slot-value ,new ,slot) (slot-value ,old ,slot)))
         ,new)))
  
  (defgeneric clone (object))
  (defmethod clone (object)
  
negative.code:     :initform nil)))
  
  (defmethod closer-mop:finalize-inheritance :after ((class data-class))
    (let* ((superclasses (closer-mop:class-precedence-list class)))
      (unless (member (find-class 'data) superclasses)
        (error "data classes must inherit from data"))))
  
  (defmethod initialize-instance :around ((slot direct-data-slot) &rest initargs)
    (declare (ignore initargs))
  