anchor.diff:    (container-slot :unknown-slot :type symbol)
     (container-index -1 :type fixnum)
     (listeners (make-array 0 :element-type 'predicate-source :adjustable t
  -			 :fill-pointer 0)
  -	     :type (array predicate-source (*))))
  +                         :fill-pointer 0)
  +             :type (array predicate-source (*))))
   
   (defun %set-container (source listeners-array slot-name index)
     (setf (event-source-listeners source) listeners-array
  -	(event-source-container-slot source) slot-name
  -	(event-source-container-index source) index))
  +        (event-source-container-slot source) slot-name
  +        (event-source-container-index source) index))
   
   (deftclass (predicate-source (:include event-source))
     (predicate (error "Bug found in skitter: predicate-sources must always be created with predicate logic")))
  
positive.code: (defmacro defcombo (name (event-var &rest sources) slots &body body)
    (assert (string= (first sources) :&source))
    (let* ((slots (append `((%step 0 fixnum)
  			  (%last-event-time 0 fixnum)
  			  (%last-step-time 0 fixnum))
  			slots))
  	 (raw-sources sources)
  	 (sources (mapcar (lambda (x)
  			    `(,(first x) ,(second x)
  			       ,@(when (third x)
  				       (list (intern (symbol-name (third x))
  						     :keyword)))))
  			  (cdr sources)))
  	 (top (gensym "top"))
  	 (reset-harder (gensym "reset-harder")))
      `(def-predicate-source ,name (,event-var ,@raw-sources) ,slots
         (macrolet ((resetting-when (predicate-form &body body)
  		    `(if ,predicate-form
  			 (progn ,@body)
  			 (reset)))
  		  ,@(loop :for (name kind slot) :in sources :append
  		       (let* ((acc (intern (format nil "~a-~a" kind slot)
  					  (symbol-package kind)))
  			      (pred
  			       `(eq (event-source-container-slot ,event-var)
  				    ',acc)))
  			 `((,name (&optional index)
  				  (if index
  				      `(,',acc ,',kind index)
  				      `(,',acc ,',kind)))
  			   (,(intern (format nil "~s-P" name)
  				     (symbol-package name))
  			     (&optional index)
  			     (if index
  				 (list 'and ',pred
  				       (list '= '(event-source-container-index
  						  ,event-var)
  					     index))
  				 ',pred))))))
  	 (let ((%time (get-internal-real-time))
  	       (,reset-harder nil))
  	   (block ,top
  	     (labels ((reset ()
  			(if ,reset-harder
  			    (reset-hard)
  			    (progn
  			      (setf %step 0)
  			      (setf ,reset-harder t)
  			      (return-from ,top (body ,event-var)))))
  		      (reset-hard ()
  			(setf %step 0)
  			(return-from ,top))
  		      (before (offset)
  			(< (- %time %last-step-time) offset))
  		      (after (offset)
  			(> (- %time %last-step-time) offset))
  		      (between (start-offset end-offset)
  			(and (after start-offset) (before end-offset)))
  		      (body (,event-var)
  			(case= %step
  			  ,@(loop for b in body for i from 0 collect
  				 `(,i ,b)))))
  	       (declare (ignorable #'reset #'reset-hard #'before
  				   #'after #'between))
  	       (let ((result (body ,event-var)))
  		 (setf %last-event-time %time)
  		 (when result
  		   (setf %last-step-time %time)
  		   (if (= %step ,(length body))
  		       (progn (setf %step 0) t)
  		       (progn (incf %step 1) nil)))))))))))
  
  ;;----------------------------------------------------------------------
  
  (deftclass (event-listener (:include predicate-source)
  			   (:constructor %make-event-listener))
    (subject nil)
    (callback (error "skitter: event-listener must be created with a callback")
  	    :type function))
  
  (defun make-event-listener (callback)
    (%make-event-listener :predicate #'%event-listener-body
  			:callback callback))
  
  (defun %event-listener-body (this evt timestamp tpref)
    (funcall (event-listener-callback this) evt timestamp tpref))
  
negative.code: (defun propagate (source timestamp tpref)
    (labels ((fire-predicate-source (predicate-source)
               (funcall (predicate-source-predicate predicate-source)
                        predicate-source source timestamp tpref)))
      (loop :for c :across (event-source-listeners source) :do
         (fire-predicate-source c))))
  
  