anchor.diff:  
   (macrolet ((def (name)
                `(progn
  -                (defgeneric ,name (mode))
  -                (defgeneric (setf ,name) (new-val mode))
                   (defmethod ,name (mode)
                     (get mode ',name))
  -                (defmethod (setf ,name) (new-val mode)
  +                (defmethod ,(alexandria:symbolicate 'set- name) (new-val mode)
                     (setf (get mode ',name) new-val)))))
     (def mode-name)
     (def mode-description)
  
positive.code:        (pushnew ',minor-mode *mode-list*)
         ,(when global
            `(setf (get ',minor-mode 'global-minor-mode-p) t))
         (setf (mode-name ',minor-mode) ,name)
         ,@(when description
             `((setf (mode-description ',minor-mode)
                     ,description)))
         ,@(when keymapp
             `((defvar ,keymap (make-keymap :name ',keymap))
               (setf (mode-keymap ',minor-mode) ,keymap)))
         (setf (mode-enable-hook ',minor-mode) ,enable-hook)
         (setf (mode-disable-hook ',minor-mode) ,disable-hook)
         (define-command (,minor-mode (:class-name ,command-class-name)) (&optional (arg nil arg-p)) ("p")
           (cond ((not arg-p)
                  (toggle-minor-mode ',minor-mode))
  
negative.code:     `(progn
         ,@(when mode-hook
             `((defvar ,mode-hook '())
               (set-mode-hook ',mode-hook ',major-mode)))
         (pushnew ',major-mode *mode-list*)
         (set-mode-name ,name ',major-mode)
         (setf (get ',major-mode 'is-major) t)
         ,@(when description
             `((set-mode-description ,description ',major-mode)))
         ,@(cond (keymap
                  `((defvar ,keymap (make-keymap :name ',keymap
                                                 :parent ,(when parent-mode
                                                            `(mode-keymap ',parent-mode))))
                    (set-mode-keymap ,keymap ',major-mode)))
                 (parent-mode
                  `((set-mode-keymap (mode-keymap ',parent-mode) ',major-mode)))
                 (t
                  `((set-mode-keymap nil ',major-mode))))
         ,(cond (syntax-table
                 `(set-mode-syntax-table ,syntax-table ',major-mode))
                (parent-mode
                 `(set-mode-syntax-table (mode-syntax-table ',parent-mode) ',major-mode))
                (t
                 `(set-mode-syntax-table (fundamental-syntax-table) ',major-mode)))
         (define-command (,major-mode (:class-name ,command-class-name)) () ()
           (clear-editor-local-variables (current-buffer))
           ,(when parent-mode `(,parent-mode))
  