anchor.diff:  (defun (setf mop-method-function) (new-value method)
     (setf (mop-slot-value method 'function) new-value))
   
  +(defmacro mop-defgeneric (function-name lambda-list &rest options)
  +  `(mop-ensure-generic-function ',function-name
  +                                :lambda-list ',lambda-list
  +                                ,@(mop-canonicalize-defgeneric-options options)))
  +
  +(defun mop-canonicalize-defgeneric-options (options)
  +  (mop-mapappend #'mop-canonicalize-defgeneric-option options))
  +
   (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))
  +(let ((mop-generic-function-table (make-hash-table :test #'equal)))
  +
  +  (defun mop-find-generic-function (symbol &optional (errorp t))
  +    (let ((gf (gethash symbol mop-generic-function-table nil)))
  +      (if (and (null gf) errorp)
  +          (error "No generic function named ~S." symbol)
  +          gf)))
  +
  +  (defun (setf mop-find-generic-function) (new-value symbol)
  +    (setf (gethash symbol mop-generic-function-table) new-value))
  +
  +  (defun mop-forget-all-generic-functions ()
  +    (clrhash mop-generic-function-table)
  +    (values))
  +
  +)
   
   (defun mop-ensure-generic-function (function-name
                                       &rest all-keys
  
positive.code:         (setf (mop-find-generic-function function-name) gf)
          gf)))
  
  (defun finalize-generic-function (gf)
    (setf (mop-generic-function-discriminating-function gf)
          (funcall (if (eq (mop-class-of gf) mop-the-class-standard-gf)
                       #'mop-std-compute-discriminating-function
  
negative.code: (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)
  