anchor.diff:  
   (define-condition multiple-initform-options-not-permitted (type-error name-mixin)
     ()
  -  :default-initargs :type 'list)
  +  (:default-initargs :type 'list))
   
   (define-condition multiple-documentation-options-not-permitted (type-error name-mixin)
     ()
  -  :default-initargs :type 'list)
  +  (:default-initargs :type 'list))
   
   (define-condition multiple-allocation-options-not-permitted (type-error name-mixin)
     ()
  -  :default-initargs :type 'list)
  +  (:default-initargs :type 'list))
   
   (define-condition multiple-type-options-not-permitted (type-error name-mixin)
     ()
  -  :default-initargs :type 'list)
  +  (:default-initargs :type 'list))
   
   (define-condition slot-documentation-option-must-be-string (type-error name-mixin)
     ()
  -  :default-initargs :type 'string)
  +  (:default-initargs :type 'string))
   
   (define-condition class-option-must-be-non-empty-list (type-error name-mixin)
     ()
  
positive.code: ;;; additional options are permitted according to the CLHS.  We follow
  ;;; the CLHS.
  
  (defmacro defclass (name direct-superclasses direct-slots &rest options)
    `(ensure-class ,name
  		 :direct-superclasses 
  		 ,(canonicalize-direct-superclasses direct-superclasses)
  		 :direct-slots
  		 ,(canonicalize-direct-slots direct-slots)
  		 ,@(canonicalize-defclass-options options)))
  		 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
negative.code: ;;; Start by creating every class as a standard instance with
  ;;; no slot storage and no metaclass. 
  
  ;; (defmacro make-class (name)
  ;;   `(defparameter ,name (allocate-standard-instance nil nil)))
  
  ;; (make-class *class-t*)
  ;; (make-class *class-standard-object*)
  ;; (make-class *class-funcallable-standard-object*)
  ;; (make-class *class-metaobject*)
  ;; (make-class *class-generic-function*)
  ;; (make-class *class-standard-generic-function*)
  ;; (make-class *class-method*)
  ;; (make-class *class-standard-method*)
  ;; (make-class *class-standard-accessor-method*)
  ;; (make-class *class-standard-reader-method*)
  ;; (make-class *class-standard-writer-method*)
  ;; (make-class *class-method-combination*)
  ;; (make-class *class-slot-definition*)
  ;; (make-class *class-direct-slot-definition*)
  ;; (make-class *class-effective-slot-definition*)
  ;; (make-class *class-standard-slot-definition*)
  ;; (make-class *class-standard-direct-slot-definition*)
  ;; (make-class *class-standard-effective-slot-definition*)
  ;; (make-class *class-specializer*)
  ;; (make-class *class-eql-specializer*)
  ;; (make-class *class-class*)
  ;; (make-class *class-built-in-class*)
  ;; (make-class *class-forward-reference-class*)
  ;; (make-class *class-standard-class*)
  ;; (make-class *class-funcallable-standard-class*)
  
  ;; ;;; Make a list of all standard-classes in top-down breadth-first
  ;; ;;; order.
  
  ;; (defparameter *standard-classes*
  ;;   (list *class-standard-object*
  ;; 	*class-funcallable-standard-object*
  ;; 	*class-metaobject*
  ;; 	*class-method*
  ;; 	*class-standard-method*
  ;; 	*class-standard-accessor-method*
  ;; 	*class-standard-reader-method*
  ;; 	*class-standard-writer-method*
  ;; 	*class-method-combination*
  ;; 	*class-slot-definition*
  ;; 	*class-direct-slot-definition*
  ;; 	*class-effective-slot-definition*
  ;; 	*class-standard-slot-definition*
  ;; 	*class-standard-direct-slot-definition*
  ;; 	*class-standard-effective-slot-definition*
  ;; 	*class-specializer*
  ;; 	*class-eql-specializer*
  ;; 	*class-class*
  ;; 	*class-built-in-class*
  ;; 	*class-forward-reference-class*
  ;; 	*class-standard-class*
  ;; 	*class-funcallable-standard-class*))
  
  ;;; Make a list of all funcallable-standard-classes in top-down
  ;;; breadth-first order.
  
  ;; (defparameter *funcallable-standard-classes*
  ;;   (list *class-generic-function* *class-standard-generic-function*))
  
  ;;; Now that every class metaobject is allocated, we can fill in the
  ;;; metaclass of each class metaobject. 
  
  ;; (defmacro set-class (class metaclass)
  ;;   `(setf (standard-instance class ,class) ,metaclass))
  
  ;; (loop for class in *standard-classes*
  ;;       do (set-class class *class-standard-class*))
  
  ;; (loop for class in *funcallable-standard-classes*
  ;;       do (set-class class *class-funcallable-standard-class*))
  
  ;; (set-class *class-t* *class-built-in-class*)
  
  ;;; Before a class metaobject can be used to create instance, it has
  ;;; to have a list of effective slot definitions, but those are
  