anchor.diff:  	   (with (symb :with- name))
   
   	   (update (symb :update))
  +	   (update-component (symb :update- name))
   	   (has (symb :has- name))
   	   (add (symb :add- name))
   	   (remove (symb :remove- name))
   
   	   (original-slot-names (mapcar #'first slot-descriptions))
  -	   (hidden-slot-names (mapcar #'hidden-name original-slot-names))
  -
  -	   (init-args (mapcar λ`(,_ ,(second _1))
  -			      original-slot-names
  -			      slot-descriptions))
  -	   (init-pairs (mapcan λ`(,(kwd _) ,_1)
  -			       hidden-slot-names
  -			       original-slot-names))
  +
  +	   (slot-names (mapcar λ(symb :% name :- (first _))
  +			       slot-descriptions))
  +
  +	   (getter-names (mapcar λ(symb name :- (first _))
  +			       slot-descriptions))
  +
  +	   (add-args (mapcar λ`(,_ ,(second _1))
  +			     original-slot-names
  +			     slot-descriptions))
  +	   (add-pairs (mapcan λ`(,(kwd _) ,_1)
  +			      slot-names
  +			      original-slot-names))
   
   	   (non-opt-init-args (mapcar λ`(,_ ,(second _1))
  -				      hidden-slot-names
  +				      slot-names
   				      slot-descriptions))
   	   (non-opt-init-pairs (mapcan λ`(,(kwd _) ,_)
  -				       hidden-slot-names))
  +				       slot-names))
   
   	   (update-args (mapcar λ`(,_ nil ,(symb :set _)) original-slot-names))
   
  
positive.code: 	       (defmethod get-system ((name ,name))
  		 (,get-system)))))))))
  
  (defun gen-slot-accessors (entity needed-slots human-slot-names
  			   gensym-slot-names body id)
    (let* ((name-pairs (mapcar #'list human-slot-names gensym-slot-names))
  	 (needed (intersection name-pairs needed-slots
  			       :test λ(eq (car _) _1)))
  	 (human-slot-names (mapcar #'first needed))
  	 (gensym-slot-names (mapcar #'second needed))
  	 (gensym-func-names (mapcar λ(gensym (symbol-name _))
  				    human-slot-names))
  
  	 (c-inst (gensym "component")))
      ;; get this component from the entity
      `(let* ((,c-inst (get-item-from-%component-bag-at
  		      (entity-components ,entity) ,id)))
         (declare (ignorable ,c-inst))
         ;; make the functions to access the slots, we need this
         ;; as otherwise you could setf
         (labels ,(mapcar λ`(,_ () (,_1 ,c-inst))
  			gensym-func-names gensym-slot-names)
  	 (declare (ignorable
  		   ,@(mapcar λ`(function ,_) gensym-func-names)))
  	 ;; make symbol macros so we can use the above functions like
  	 ;; symbols again
  	 (symbol-macrolet ,(mapcar λ`(,_ (,_1))
  				   human-slot-names
  				   gensym-func-names)
  	   ,@body)))))
  
  (defun valid-slot-descriptions-p (slot-descriptions)
    (labels ((valid-slot (s)
  	     (destructuring-bind (name default &key type) s
  
negative.code:     (assert (valid-slot-descriptions-p slot-descriptions))
      (let* ((system-name (symb name :-system))
  	   (payload (symb :% name :-payload))
  	   (payload-type (hidden-name (symb name :-payload)))
  
  	   (reactive (eq (first depends-on) :reactive))
  	   (friends (if reactive (rest depends-on) depends-on))
  
  	   (let-id (hidden-name (symb name :-id)))
  	   (id (gensym "id"))
  
  	   (init (symb :make- name))
  