anchor.diff:    (actions nil))
   
   (defun make-test-pattern (p)
  -  (list p))
  +  (list "test" p))
   
   (defun make-negated-pattern (p)
     (list p))
  
positive.code: ;;; File: language.lisp
  ;;; Description: Macros that implement the LISA programming language.
  ;;;
  ;;; $Id: language.lisp,v 1.4 2000/10/17 02:08:22 youngde Exp $
  
  (in-package "LISA")
  
  
negative.code: (defun make-rule-pattern (template &optional (assign-to nil))
    (labels ((parse-pattern (p)
               (format t "parse-pattern: looking 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-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-fact-body: looking at ~S~%" body)
               (let ((slot (first body)))
                 (cond ((consp slot)
                        (parse-fact-body (rest body)
                                         (append slots
                                                 `(,(parse-slot slot)))))
                       ((null slot)
                        (values slots))
                       (t
  