anchor.diff:  (defmodule respond respond-module ("learn" "lookup")
     (responses :accessor responses-of)    ; hashtable of responses to exact matches
     (regexes :accessor regexes-of))       ; ordered list of regular expressions to match
  -
  -(defun get-addressed-text (nick text)
  -  (ppcre:register-groups-bind (extracted-nick extracted-text)
  -      ("^([^:, ]+)[:,]\\s*(.*)" text)
  -    (when (equalp nick extracted-nick)
  -      extracted-text)))
   
   (defmethod initialize-module ((module respond-module) config)
     ;; regexes loaded by configuration
  
positive.code:   (destructuring-bind (channel text)
        (arguments message)
      (declare (ignore channel))
      (let ((addressed-text (get-addressed-text (nickname (user (connection message))) text)))
        (cond
          (addressed-text
           (when (extract-learnable (responses-of module)
                                    (source message)
                                    addressed-text)
             (save-response-db (responses-of module) "data/responses.lisp")
             (reply-to message "~a: Okay." (source message))))
          (t
           (loop
              for response in (regexes-of module)
              as match = (ppcre:scan (first response) text)
              when match
              do (reply-to message (random-elt (rest response))))
           (let ((responses (gethash (string-downcase text) (responses-of module))))
             (when responses 
               (reply-to message "~a" (random-elt responses))))))))
    nil)
  
  (defmethod handle-command ((module respond-module)
  
negative.code: 
  (in-package #:orcabot)
  
  (defparameter +learn-regexes+ (mapcar (lambda (p)
                                          (cl-ppcre:create-scanner p :case-insensitive-mode t))
                                        '("(.*?)\\s+(is|are|am|isn't|aren't)\\s+(.*)"
                                          "(.*?)\\s+<(\\S+)>\\s*(.*)")))
  (defparameter +address-regexes+ (mapcar (lambda (p)
                                            (list* (cl-ppcre:create-scanner (first p) :case-insensitive-mode t)
                                                   (rest p)))
                                        '(("^([^:, ]+)[:,]\\s*(.*)" 0 1)
                                          ("(.*),\\s*(.*)$" 1 0))))
  
  (defun load-response-db (db path)
    (clrhash db)
    (dolist (x (with-open-file (inf path :direction :input :if-does-not-exist nil)
  