anchor.diff:  
   ;; TODO: Because our hooks are typed, having both `run-hook` and
   ;; `run-hook-with-args' makes little sense.  Remove `run-hook-with-args'?
  -(defmethod run-hook-with-args ((hook hook) &rest args)
  -  (apply (combination hook) hook args))
  +;; (defmethod run-hook-with-args ((hook hook) &rest args)
  +;;   (apply (combination hook) hook args))
   
   ;; TODO: Implement the following methods? Isn't the `combination' slot more general?
   ;; (defmethod run-hook-with-args-until-failure ((hook hook) &rest args)
  
positive.code:   (apply (apply #'alexandria:compose (mapcar #'fn (handlers hook))) args))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;; Compile-time type checking for add-hook is useful in case `add-hook' is not
  ;; run when the user config is loaded.  We declaim the type for `add-hook'
  ;; because `satisfies' takes the object (the `add-hook' function) as argument,
  ;; but we have no way to access the hook or the handler passed as parameter.
  
  (defmethod add-hook ((hook hook) (handler handler) &key append)
    (serapeum:synchronized (hook)
      (if (not append)
          (pushnew handler (handlers hook) :test #'equals)
          (unless (member handler (handlers hook))
            (alexandria:appendf (symbol-value hook) (list handler))))))
  
  (defmethod add-hook ((hook hook) fn &key append)
    "Add FN to HOOK.
  FN cannot be an anonymous function.
  To add anonymous functions to HOOK, use
  
    (add-hook hook (make-handler (lambda () ...) :name ...))"
    (let ((handler (make-handler fn)))
      (add-hook hook handler :append append)))
  
  ;; (defmacro add-hook* (hook handler &key append)
  ;;   (when (hook-type hook)
  ;;     (assert (typep (fn handler) (hook-type hook)) ((fn handler))
  ;;             'type-error :datum (fn handler) :expected-type (hook-type hook)))
  ;;   `(progn
  ;;      (add-hook ,hook ,handler :append ,append)))
  
  (defmethod remove-hook ((hook hook) (fn handler))
    (serapeum:synchronized (hook)
  
negative.code: (defvar %hook-table (make-hash-table :test #'equal)
    "")
  
  (defun define-hook (name &key object handlers disabled-handlers combination)
    "Create a globally accessible hook."
    (let ((hook
            (make-instance 'hook          ; TODO: Handler class?
                           :handlers handlers
                           :disabled-handlers disabled-handlers
                           :combination combination)))
  