anchor.diff:                                                (*servers* . ,*servers*))))
          ,uidgens)))
   
  -(defgeneric dispatch (module event &key &allow-other-keys)
  -  (:documentation "Handle a new event and distribute it to the registered handler functions.")
  -  (:method ((module T) (event event) &key ignore-errors)
  -    (loop for module being the hash-values of *bot-modules*
  -          if (active module)
  -            do (when (if ignore-errors 
  -                         (ignore-errors (dispatch module event)) 
  -                         (dispatch module event))
  -                 (return-from dispatch))))
  -
  -  (:method ((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)))
  -
  -  (:method ((module module) (event command-event) &key)
  -    (let ((handler (gethash (command event) (commands module))))
  -      (when handler
  -        (v:trace (name module) "Dispatching: ~a" event)
  -        (with-module-thread module
  -          (handler-bind
  -              ((error #'(lambda (err)
  -                          (v:warn (find-symbol (string-upcase (class-name (class-of module))) :KEYWORD) "Unhandled condition: ~a" err)
  -                          (respond event "Unhandled condition: ~a" err)
  -                          (when *debugger*
  -                            (invoke-debugger err)))))
  -            (handler-case
  -                (funcall (cmd-fun handler) module event)
  -              (not-authorized (err)
  -                (v:warn (name *current-server*) "User ~a attempted to execute ~a, but is not authorized!" (nick (event err)) (command (event err)))
  -                (respond (event err) (fstd-message (event err) :not-authorized)))
  -              (invalid-arguments (err)
  -                (v:warn (name *current-server*) "Invalid arguments to ~a, expected ~a" (command err) (argslist err))
  -                (respond event "Invalid arguments. Expected: ~a" (argslist err))))))
  -        T))))
  -
  -(defgeneric get-command (module commandname)
  -  (:documentation "Get the command instance associated with the command name.")
  -  (:method ((module module) commandname)
  -    (gethash (string-downcase commandname) (commands module))))
  -
  -(defgeneric get-group (module group-symbol)
  -  (:documentation "Return the hash-map defining the group.")
  -  (:method ((module module) group)
  -    (gethash (string-downcase group) (groups module))))
  -
  -(defgeneric get-group-command (module group-symbol commandname)
  -  (:documentation "Return the function symbol to the group-command.")
  -  (:method ((module module) group commandname)
  -    (let ((group (get-group module group)))
  -      (when group (gethash commandname group)))))
  -
  -(defgeneric get-module (module-name)
  -  (:documentation "Return a module by its name.")
  +(defgeneric to-module-name (name-object)
  +  (:documentation "Attempts to transform the given object into the keyword name for a module.")
  +  (:method ((module-instance module))
  +    (to-module-name (princ-to-string (class-name (class-of module-instance)))))
  +  
     (:method ((module-name string))
  -    (let ((symbol (find-symbol (string-upcase module-name) :KEYWORD)))
  -      (when symbol
  -        (get-module symbol))))
  +    (find-symbol (string-upcase module-name) :KEYWORD))
   
     (:method ((module-name symbol))
  -    (unless (keywordp module-name)
  -      (get-module (symbol-name module-name)))
  -    (gethash module-name *bot-modules*)))
  +    (if (keywordp module-name)
  +        module-name
  +        (to-module-name (symbol-name module-name)))))
  +
  +(defun get-module (designator)
  +  (gethash (to-module-name module-name) *bot-modules*))
   
   (defmethod name ((module module))
  -  (find-symbol (format NIL "~a" (class-name (class-of module))) :KEYWORD))
  +  (find-symbol (princ-to-string (class-name (class-of module))) :KEYWORD))
   
   (defun package-symbol (package)
     "Returns the symbol of a package."
  
positive.code: 
  (defclass module ()
    ((%active :initform NIL :accessor active :allocation :class)
     (%handlers :initform (make-hash-table :test 'equal) :reader handlers :allocation :class)
     (%commands :initform (make-hash-table :test 'equal) :reader commands :allocation :class)
     (%groups :initform (make-hash-table :test 'equal) :reader groups :allocation :class)
     (%threads :initform (make-hash-table :test 'equalp) :accessor threads))
    (:documentation "Base module class."))
  
  (defmethod active ((null null)) NIL)
  (defmethod active ((module-name symbol))
    (active (get-module module-name)))
  (defmethod active ((module-name string))
    (active (get-module module-name)))
  
  (defmethod print-object ((module module) stream)
    (format stream "<[~a]>" (class-name (class-of module))))
  
  (defclass command ()
    ((%name :initform (error "Name required.") :initarg :name :accessor name)
     (%args :initform () :initarg :arguments :accessor cmd-args)
     (%func :initform (error "Function required.") :initarg :function :accessor cmd-fun)
     (%docu :initform NIL :initarg :documentation :accessor docu))
    (:documentation "Class for module commands."))
  
  (defgeneric start (module)
    (:documentation "Start the module and activate it for use.")
  
negative.code:   (:method ((module module))))
  
  (defgeneric stop (module)
    (:documentation "Stop the module and attempt to clean everything up.")
    (:method :around ((module module))
      (setf (active module) NIL)
      (loop for uid being the hash-keys of (threads module)
  