anchor.diff:  (defun mop-canonicalize-defclass-options (options)
     (mop-mapappend #'mop-canonicalize-defclass-option options))
   
  +; Stub
  +(defun mop-make-instance (class-name &rest all-keys)
  +  (list class-name all-keys))
  +
  +(let ((mop-class-table (make-hash-table :test #'eq)))
  +
  +  (defun mop-find-class (symbol &optional (errorp t))
  +    (let ((class (gethash symbol mop-class-table nil)))
  +      (if (and (null class) errorp)
  +          (error "No class named ~S." symbol)
  +          class)))
  +
  +  (defun (setf mop-find-class) (new-value symbol)
  +    (setf (gethash symbol mop-class-table) new-value))
  +
  +  (defun mop-forget-all-classes ()
  +    (clrhash mop-class-table)
  +    (values))
  +
  +)
  +
   (defun mop-ensure-class (name &rest all-keys)
     (if (mop-find-class name nil)
         (error "Can't redefine the class named ~S." name)
  
positive.code: (defun (setf mop-method-function) (new-value method)
    (setf (mop-slot-value method 'function) new-value))
  
  (defun mop-canonicalize-defgeneric-option (option)
    (case (car option)
      (:generic-function-class (list ':generic-function-class `(find-class ',(cadr option))))
      (:method-class (list ':method-class `(find-class ',(cadr option))))
      (otherwise (list `',(car option) `',(cadr option)))))
  
  (defun mop-canonicalize-defgeneric-options (options)
    (mop-mapappend #'mop-canonicalize-defgeneric-option options))
  
  (defun mop-ensure-generic-function (function-name
                                      &rest all-keys
  
negative.code:                ,@(when writers `(:writers ',writers))
                 ,@other-options))))
  
  (defun mop-canonicalize-direct-superclasses (direct-superclasses)
    `(list ,@(mapcar #'mop-canonicalize-direct-superclass direct-superclasses)))
  
  (defun mop-canonicalize-direct-superclass (class-name)
    `(find-class ',class-name))
  
  (defun mop-canonicalize-defclass-option (option)
    (case (car option)
  