anchor.diff:  (defun make-rule-pattern (template &optional (assign-to nil))
     (labels ((parse-pattern (p)
                (format t "parse-pattern: looking at ~S~%" p)
  -             (flet ((identifierp (obj)
  -                      (or (symbolp obj)
  -                          (stringp obj)
  -                          (numberp obj))))
  -               (let ((head (first p)))
  -                 (if (symbolp head)
  -                     (cond ((eq head 'test)
  -                            (make-test-pattern (rest p)))
  -                           ((eq head 'not)
  -                            (make-negated-pattern
  -                             (parse-pattern (first (rest p)))))
  -                           (t
  -                            (let ((fact-body (second p)))
  -                              (cond ((consp fact-body)
  -                                     (parse-unordered-fact p))
  -                                    ((identifierp fact-body)
  -                                     (parse-ordered-fact p))
  -                                    (t (error "Parse error at ~S~%" fact-body))))))
  -                   (error "Parse error at ~S~%" p))))))
  +             (let ((head (first p)))
  +               (if (symbolp head)
  +                   (cond ((eq head 'test)
  +                          (make-test-pattern (rest p)))
  +                         ((eq head 'not)
  +                          (make-negated-pattern
  +                           (parse-pattern (first (rest p)))))
  +                         (t
  +                          (parse-fact p)))
  +                 (error "Parse error at ~S~%" p)))))
       (if (null assign-to)
           (make-pattern (parse-pattern template))
         (make-assignment-pattern (parse-pattern template)))))
  -
  -(defun parse-ordered-fact (fact)
  -  (format t "parsed-ordered-fact: looking at ~S~%" fact)
  -  (labels ((parse-fields (body &optional facts)
  -             (let ((field (first body)))
  -               (cond ((null field)
  -                      (values facts))
  -                     ((field-constantp field)
  -                      (parse-fields (rest body)
  -                                    (append fields `(,field))))
  -                     ((varnamep field)
  -                      (if (consp (second body))
  -                          (parse-fields
  -                           (first (rest body))
  -                           (append facts `(,field ,(second body))))
  -                        (parse-fields
  -                         (rest body)
  -                         (append facts `(,field)))))
  -                     (t (error "parse-fields: parse error at ~S~%" body))))))
  -    (parse-fields fact)))
  -
  -(defmacro with-fact-components (((name field constraint) fact) &body body)
  -  `(destructuring-bind (,name &optional ,field ,constraint) ,fact
  -    ,@body))
           
  -(defun parse-unordered-fact (fact)
  +(defun parse-fact (fact)
     (format t "parsed-unordered-fact: looking at ~S~%" fact)
     (labels ((parse-slot (slot)
                (with-slot-components ((name field constraint) slot)
                  (list name field constraint)))
              (parse-fact-body (body &optional (slots nil))
  -             (format t "parse-unordered-fact-body: looking at ~S~%" body)
  +             (format t "parse-fact-body: looking at ~S~%" body)
                (let ((slot (first body)))
                  (cond ((consp slot)
                         (parse-fact-body (rest body)
  -                                       (append slots (parse-slot slot))))
  +                                       (append slots
  +                                               `(,(parse-slot slot)))))
                        ((null slot)
                         (values slots))
                        (t
  
positive.code: 
  (defun redefine-defrule (name body)
    (multiple-value-bind (doc-string decls lhs rhs)
        (evaluate-defrule body)))
        
  (defun evaluate-defrule (body)
    (format t "evaluate-defrule: looking at ~S~%" body)
  
negative.code:   (list p))
  
  (defmacro variablep (sym)
    `(and (symbolp ,sym)
      (eq (elt (symbol-name ,sym) 0) #\?)))
  
  (defmacro identifierp (sym)
    `(or
      (symbolp ,sym)
      (numberp ,sym)
      (stringp ,sym)))
  
  (defmacro with-slot-components (((name field constraint) slot) &body body)
    `(destructuring-bind (,name ,field &optional ,constraint) ,slot
  