anchor.diff:  			      (second s)))
   		    (init (if array?
   			      (if (numberp len)
  -				  `(make-array ,len :element-type ',elem-type)
  +				  `(make-array ,len :element-type ',elem-type
  +					       :fill-pointer 0)
   				  `(make-array 0 :element-type ',elem-type
   					       :adjustable t :fill-pointer 0))
   			      `(,(intern (format nil "MAKE-~a" type)
   					 (symbol-package type))))))
   	       `(,name ,init :type ,type))))
  -    `(deftclass ,name
  -       ,@(mapcar #'parse-slot slots))))
  +    (let* ((slot-names (mapcar #'first slots))
  +	   (types (mapcar #'second slots))
  +	   (accessor-names (mapcar (lambda (x)
  +				     (intern (format nil "~a-~a" name x)
  +					     (symbol-package name)))
  +				   slot-names))
  +	   (lengths (mapcar #'third slots)))
  +      (when (> (length types) (length (remove-duplicates types)))
  +	(error "multiple slots found with the same type, this is no allowed in defkind"))
  +      `(progn
  +	 (deftclass ,name
  +	   ,@(mapcar #'parse-slot slots))
  +	 ,@(remove nil
  +		   (mapcar (lambda (x a l)
  +			     (when l
  +			       (let ((push (if (numberp l)
  +					       'vector-push
  +					       'vector-push-extend)))
  +				 `(defmethod add ((inst ,name) (source ,x))
  +				    (,push source (,a inst))))))
  +			   types
  +			   accessor-names
  +			   lengths))))))
   
   (defkind mouse
     (pos xy-pos)
  
positive.code: ;;----------------------------------------------------------------------
  
  (defmacro def-event-source (name &body slots)
    (let* ((id (or (gethash name *ids*) (%next-id)))
  	 (make (intern (format nil "MAKE-~a" name) (symbol-package name)))
  	 (apply (intern (format nil "APPLY-~a" name) (symbol-package name)))
  	 (add (intern (format nil "ADD-~a" name) (symbol-package name)))
  	 (add-n (intern (format nil "ADD-N-~a" name) (symbol-package name)))
  	 (slot-names (mapcar #'first slots))
  	 (accessor-names (mapcar (lambda (x)
  				   (intern (format nil "~a-~a" name x)
  					   (symbol-package name)))
  				 slot-names))
  	 (did-set (mapcar #'gensym (mapcar #'symbol-name slot-names))))
      `(progn
         (setf (gethash ',name *ids*) ,id)
         (deftclass (,name (:include regular-source)) ,@slots)
         (defun ,apply (group index &key ,@(mapcar (lambda (x y) `(,x nil ,y))
  						 slot-names did-set))
  	 (let ((it (aref (aref (source-group-sources group) ,id) index)))
  	   ,@(mapcar (lambda (x y z) `(when ,y (setf (,z it) ,x)))
  		     slot-names did-set accessor-names))
  	 ;; new events :)
  	 )
         (defun ,add (group)
  	 (let ((g (source-group-sources group)))
  	   (make-n-long g ,id)
  	   (vector-push-extend (,make) (aref g ,id) )))
         (defun ,add-n (n group)
  	 (loop :for i :below n :do (,add group))
  	 group))))
  
  (def-event-source button
    (down-p nil :type boolean))
  
negative.code: (def-event-source wheel
    (val 0f0 :type single-float))
  
  ;; (apply-button x ts :down-p t)
  
  ;;----------------------------------------------------------------------
  
  (defun propagate (source timestamp)
    (labels ((fire-combo (combo source timestamp)
  	     (funcall (combo-predicate combo) combo source timestamp)))
      (loop :for c :in (event-source-combos source) :do
         (fire-combo c source timestamp))))
  
  (defmacro def-combo (name source-types (&key event-var (timestamp-var 'timestamp))
  
  					  slots &body body)
    (assert (symbolp event-var))
    (assert (listp source-types))
    (let* (;; funcs
  	 (make (intern (format nil "MAKE-~a" name) (symbol-package name)))
  	 (constructor (intern (format nil "%MAKE-~a" name) (symbol-package name)))
  	 (logic (intern (format nil "%~a-BODY" name) (symbol-package name)))
  	 (active (intern (format nil "~s-ACTIVE-P" name)
  			 (symbol-package name)))
  	 ;;state-slots
  	 (original-slot-names (mapcar #'first slots))
  	 (accessor-names (mapcar (lambda (x)
  