anchor.diff:  (defmethod dispatch ((module module) (event event) &key)
     (let ((handler (gethash (string-downcase (class-name (class-of event))) (handlers module))))
       (when handler
  +      (v:trace (name module) "Dispatching: ~a" event)
         (with-module-thread module
           (funcall handler module event))
         NIL)))
  
positive.code:   (setf (gethash (string-downcase eventtype) (handlers module)) method))
  
  (defmacro with-module-thread (module &body thread-body)
    (let ((uidgens (gensym "UUID")))
      `(let ((,uidgens (uuid:make-v4-uuid)))
         (setf (gethash ,uidgens (threads ,module))
               (make-thread #'(lambda ()
                                ,@thread-body
                                (remhash ,uidgens (threads ,module)))
                            :initial-bindings `((*current-server* . ,*current-server*)
                                                (*servers* . ,*servers*)))))))
  
  (defmethod dispatch ((module T) (event event) &key ignore-errors)
    (loop for module being the hash-values of *bot-modules*
  
negative.code:     (when group (gethash commandname group))))
  
  (defmethod get-module ((module-name string))
    (let ((symbol (find-symbol (string-upcase module-name) :KEYWORD)))
      (when symbol
        (get-module symbol))))
  
  (defmethod get-module ((module-name symbol))
    (unless (keywordp module-name)
      (get-module (symbol-name module-name)))
    (gethash module-name *bot-modules*))
  
  (defmethod name ((module module))
    (find-symbol (format NIL "~a" (class-name (class-of module))) :KEYWORD))
  
  (defun package-symbol (package)
    "Returns the symbol of a package."
  