anchor.diff:  (defun propagate (source timestamp tpref)
     (labels ((fire-predicate-source (predicate-source)
                (funcall (predicate-source-predicate predicate-source)
  -		      predicate-source source timestamp tpref)))
  +                      predicate-source source timestamp tpref)))
       (loop :for c :across (event-source-listeners source) :do
          (fire-predicate-source c))))
   
  
positive.code:                                                'vector-push
                                                 'vector-push-extend)))
                                   `(defmethod add ((inst ,name) (source ,x))
  				    (let ((arr (,a inst)))
  				      (,push source arr)
  				      (%set-container
  				       source (,ls inst) ',o
  				       (position source arr)))))))
                             types
                             hidden-slot-names
                             lengths
  			   listener-slot-names
  			   original-slot-names))
  	 (defmethod remove-listener ((listener predicate-source) (input ,name))
  	   ,@(loop :for l :in listener-slot-names :collect
  		`(shifting-remove (,l input) listener *null-listener*))
  	   nil)
  	 (defmethod listen-to ((listener predicate-source) (input ,name)
  			       &optional slot-name)
  	   (let ((arr
  		  (ecase slot-name
  		    ,@(loop :for (s) :in slots
  			 :for l :in listener-slot-names :collect
  			 `(,(intern (symbol-name s) :keyword)
  			    (,l input))))))
  	     (vector-push-extend listener arr)
  	     (values listener input)))))))
  
  (defun shifting-remove (arr element &optional blank)
    (let ((count 0)
  	(adjustable (adjustable-array-p arr)))
      (loop :for e :across arr :for i :from 0 :do
         (if (eq e element)
  	   (progn
  	     (setf (aref arr i) blank)
  	     (incf count))
  	   (when (> count 0)
  	     (setf (aref arr (- i count)) (aref arr i))
  	     (setf (aref arr i) blank))))
      (when adjustable
        (decf (fill-pointer arr) count))
      arr))
  
negative.code: 
  (defmacro whilst-listening-to (mappings &body body)
    (let* ((callback-vars (loop :for m :in mappings
                             :do (identity m)
                             :collect (gensym)))
           (callback-attach-to (loop :for m :in mappings :collect
                                  (remove nil m))))
      `(let (,@callback-vars)
         (unwind-protect
              (progn
                ,@(loop :for v :in callback-vars
                     :for a :in callback-attach-to :collect
                     `(setf ,v (listen-to ,@a)))
                ,@body)
           ,@(loop :for v :in callback-vars :collect
                `(when ,v (stop-listening ,v)))))))
  