anchor.diff:      (%direct-subclasses :initform '() :accessor class-direct-subclasses)
       (%direct-methods :initform '() :accessor class-direct-methods)))
   
  -(defparameter *effective-slots-standard-class*
  -  (combine-slots *effective-slots-class*
  -		 *direct-slots-standard-class*))
  -
  -;; Slots for FUNCALLABLE-STANDARD-CLASS
  -(defparameter *direct-slots-funcallable-standard-class*
  +(define-slots 'funcallable-standard-class '(class)
     '())
   
  -(defparameter *effective-slots-funcallable-standard-class*
  -  (combine-slots *effective-slots-class*
  -		 *direct-slots-funcallable-standard-class*))
  -
  -) ; eval-when+) ; eval-when
  
positive.code: 
  (eval-when (:compile-toplevel :load-toplevel :execute)
  
  (defun combine-slots (&rest to-combine)
    (remove-duplicates (reduce #'append to-combine) :from-end t))
  
  ;;; Slots for T.
  (defparameter *direct-slots-t*
    '())
  
  (defparameter *effective-slots-t*
    *direct-slots-t*)
  
  ;;; Slots for STANDARD-OBJECT.
  (defparameter *direct-slots-standard-object*
    '((%version-information :initarg :version-information :initform nil)))
  
  (defparameter *effective-slots-standard-object*
    (combine-slots *effective-slots-t*
  		 *direct-slots-standard-object*))
  
  ;;; Slots for FUNCTION.
  (defparameter *direct-slots-function*
    '())
  
  (defparameter *effective-slots-function*
    *direct-slots-function*)
  
  ;;; Slots for FUNCALLABLE-STANDARD-OBJECT.
  (defparameter *direct-slots-funcallable-standard-object*
    ;; FIXME, maybe add something here? 
    '())
  
  (defparameter *effective-slots-funcallable-standard-object*
    (combine-slots *effective-slots-standard-object*
  		 *effective-slots-function*
  		 *direct-slots-funcallable-standard-object*))
  
  ;;; Slots for METAOBJECT.
  (defparameter *direct-slots-metaobject*
    '())
  
  (defparameter *effective-slots-metaobject*
    (combine-slots *effective-slots-standard-object*
  		 *direct-slots-metaobject*))
  
  ;;; Slots for GENERIC-FUNCTION.
  (defparameter *direct-slots-generic-function*
    ;; FIXME: add more here
    '())
  
  (defparameter *effective-slots-generic-function*
    (combine-slots *effective-slots-metaobject*
  		 *effective-slots-funcallable-standard-object*
  		 *direct-slots-generic-function*))
  
  ;;; Slots for STANDARD-GENERIC-FUNCTION.
  (defparameter *direct-slots-standard-generic-function*
    '())
  
  (defparameter *effective-slots-standard-generic-function*
    (combine-slots *effective-slots-generic-function*
  		 *direct-slots-standard-generic-function*))
  
  ;;; Slots for METHOD
  (defparameter *direct-slots-method*
    '())
  
  (defparameter *effective-slots-method*
    (combine-slots *effective-slots-metaobject*
  		 *direct-slots-method*))
  
  ;;; Slots for STANDARD-METHOD
  (defparameter *direct-slots-standard-method*
    '())
  
  (defparameter *effective-slots-standard-method*
    (combine-slots *effective-slots-method*
  		 *direct-slots-standard-method*))
  
  ;;; Slots for STANDARD-ACCESSOR-METHOD
  (defparameter *direct-slots-standard-accessor-method*
    '())
  
  (defparameter *effective-slots-standard-accessor-method*
    (combine-slots *effective-slots-standard-method*
  		 *direct-slots-standard-accessor-method*))
  
  ;;; Slots for STANDARD-READER-METHOD
  (defparameter *direct-slots-standard-reader-method*
    '())
  
  (defparameter *effective-slots-standard-reader-method*
    (combine-slots *effective-slots-standard-accessor-method*
  		 *direct-slots-standard-reader-method*))
  
  ;;; Slots for STANDARD-WRITER-METHOD
  (defparameter *direct-slots-standard-writer-method*
    '())
  
  (defparameter *effective-slots-standard-writer-method*
    (combine-slots *effective-slots-standard-accessor-method*
  		 *direct-slots-standard-writer-method*))
  
  ;;; Slots for METHOD-COMBINATION
  (defparameter *direct-slots-method-combination*
    '())
  
  (defparameter *effective-slots-method-combination*
    (combine-slots *effective-slots-metaobject*
  		 *direct-slots-method-combination*))
  
  ;;; Slots for SLOT-DEFINITION
  (defparameter *direct-slots-slot-definition*
    '((%name :initarg :name :reader slot-definition-name)
      (%allocation :initarg :allocation
  		 :initform :instance
  
negative.code:     (%initform :initarg :initform :reader slot-definition-initform)
      (%initfunction :accessor slot-definition-initfunction)))
  
  ;;; The READERS and WRITERS slots only exist in direct slot
  ;;; definitions, because they are not combined the way other slot
  ;;; properties are when an effective slot definition is computer.
  (define-slots 'direct-slot-definition '(slot-definition)
    '((%readers :initarg :readers :reader slot-definition-readers)
      (%writers :initarg :writers :reader slot-definition-writers)))
  
  (define-slots 'effective-slot-definition '(slot-definition)
    '((%position :initarg :position :reader slot-definition-position)))
  
  (define-slots 'standard-slot-definition '(slot-definition)
    '())
  
  (define-slots 'standard-direct-slot-definition
    '(slot-definition direct-slot-definition)
    '())
  
  (define-slots 'standard-effective-slot-definition
    '(slot-definition effective-slot-definition)
    '())
  
  (define-slots 'specializer '(metaobject)
    '())
  
  (define-slots 'eql-specializer '(specializer)
    '())
  
  (define-slots 'class '(specializer)
    '((%unique-number :initform nil :accessor class-unique-number)))
  
  (define-slots 'built-in-class '(class)
    '())
  
  (define-slots 'forward-reference-class '(class)
    '())
  
  (define-slots 'standard-class '(class)
  '((%name :initarg :name :accessor class-name)
      (%direct-superclasses :accessor class-direct-superclasses)
      (%direct-slots :accessor class-direct-slots)
      (%precedence-list :initform '() :accessor class-precedence-list)
  