anchor.diff:  
   (defclass indexed-priority-list ()
     ((priority-vector :reader get-priority-vector)
  -   (inodes :initform nil
  +   (inodes :initform '()
              :accessor get-inodes)
      (delta :accessor get-delta)
      (insertion-function :initarg :insertion-function
  
positive.code: ;;; Description: Classes that implement the various default conflict
  ;;; resolution strategies for Lisa's RETE implementation.
  
  ;;; $Id: strategies.lisp,v 1.24 2001/03/28 00:08:50 youngde Exp $
  
  (in-package "LISA")
  
  
negative.code: (defun make-indexed-priority-list (func)
    (make-instance 'indexed-priority-list :insertion-function func))
  
  (defclass builtin-strategy (strategy)
    ((priority-queue :reader get-priority-queue))
    (:documentation
     "A base class for all LISA builtin conflict resolution strategies."))
    
  (defmethod add-activation ((self builtin-strategy) activation)
    (insert-activation (get-priority-queue self) activation))
  
  (defmethod find-activation ((self builtin-strategy) rule token)
    (lookup-activation (get-priority-queue self) rule token))
  
  (defmethod next-activation ((self builtin-strategy))
    (get-next-activation (get-priority-queue self)))
  
  (defmethod remove-activations ((self builtin-strategy))
    (reset-activations (get-priority-queue self)))
  
  (defmethod list-activations ((self builtin-strategy))
    (get-all-activations (get-priority-queue self)))
  
  (defclass depth-first-strategy (builtin-strategy)
    ()
    (:documentation
     "A depth-first conflict resolution strategy."))
  
  (defmethod initialize-instance :after ((self depth-first-strategy) &rest args)
    (declare (ignore args))
    (setf (slot-value self 'priority-queue)
      (make-indexed-priority-list
       #'(lambda (obj place) (push obj place)))))
  
  (defun make-depth-first-strategy ()
    (make-instance 'depth-first-strategy))
  
  (defclass breadth-first-strategy (builtin-strategy)
    ()
    (:documentation
     "A breadth-first conflict resolution strategy."))
  
  (defmethod initialize-instance :after ((self breadth-first-strategy) &rest args)
    (declare (ignore args))
    (setf (slot-value self 'priority-queue)
      (make-indexed-priority-list
       #'(lambda (obj place) (nconc place `(,obj))))))
  
  (defun make-breadth-first-strategy ()
    (make-instance 'breadth-first-strategy))
  