anchor.diff:  		       'event
   		       ;; building arguments for make-instance:
   		       ;; if args is nil, leave slot unbound
  -		       (append (list :id (fresh-id)
  +		       (append (list :id (fresh-event-id)
   				     :time (+ delay
   					      (gettime))
  -				     :fn fn)
  +				     :fn fn
  +				     :owner-path (path act))
   			       (if (null args)
   				   nil
   				   (list :args args))))))
  -	(setf (events-of act)
  -	      (sort (cons ev
  -			  (events-of act))
  -		    #'< :key #'time-of))
  -	(values act ev))))
  -
  -
  -(defmethod evolve ((obj object))
  -  obj)
  -
  -
  -(defmethod evolve ((act actor))
  -  (let ((ev (imminent-event act)))
  -    (if ev
  +	(values (sort (cons ev events)
  +		      #'< :key #'time-of)
  +		act ev))))
  +
  +
  +(defmethod evolve ((act actor) (evs list))
  +  (let ((ev (first evs)))
  +    (if (belongs act ev)
   	(apply (fn-of ev)
   	       (append (list act)
   		       (if (slot-boundp ev 'args)
   			   (args-of ev))))
  -	(call-next-method))))
  -
  -
  -(defmethod evolve ((sim simulator))
  -  (evolve (cdr (the (cons event actor)
  -		 (first
  -		  (sort
  -		   (remove-if #'null
  -			      (mapcar (lambda (comp)
  -					(cons (imminent-event comp)
  -					      comp))
  -				      (components-list sim)))
  -		   #'< :key (lambda (cell)
  -			      (time-of (car cell)))))))))
  +	(error 'error-invalid))))
  +
  +
  +(defmethod evolve ((sim simulator) (evs list))
  +  (let ((next-ev (first evs)))
  +    (if (belongs sim next-ev)
  +	(call-next-method)
  +	(let ((evolving (find-if (lambda (component)
  +				   (path-starts-with (owner-path-of next-ev)
  +						     (path component)))
  +				 (components-list sim))))
  +	  (if evolving
  +	      (evolve evolving evs)
  +	      ;; next-ev's owner not found, discard it and keep going
  +	      (evolve sim (rest evs)))))))
  
positive.code: 
  ;; GENERICS
  
  (defgeneric next-to-evolve (obj &optional next time)
    (:documentation "TODO"))
  
  
  (defgeneric evolve (obj)
    (:documentation "obj can execute its event and evolve
    accordingly. Returns the new version of obj."))
  
  
  (defgeneric components-list (sim)
    (:documentation "Returns the list representation of their
    components."))
  
  
  (defgeneric imminent-event (obj &optional max-time)
    (:documentation "Return the function and the time of the next event
    of obj."))
  
  
  (defgeneric schedule (delay function actor &rest args)
    (:documentation "TODO"))
  
  
  
negative.code: 
  
  (defclass event (with-id)
    ((owner-path
      :initarg :owner-path
      :initform (error ":owner-path missing")
      :accessor owner-path-of
      :type list)
     (time
      :initarg :time
      :initform (error ":time missing")
      :accessor time-of
  