anchor.diff:  (defmethod handle-command ((module respond-module)
                              (command (eql 'learn))
                              message args)
  -  "learn <term> ( is | isn't | are | aren't | < verb > ) <tidbit> - learn a new response"
  +  "learn <term> ( am | is | isn't | are | aren't | < <verb> > | < reply > ) <tidbit> - learn a new response"
     (let ((text (join-string " " args)))
       (cond
         ((extract-learnable (responses-of module)
  
positive.code: (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
  
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)
  