anchor.diff:  
   
   (defclass csp-scenario (simulator)
  -  ((persons
  -    :accessor persons-of
  -    :type (cons person person))
  -   (cans
  -    :accessor cans-of
  -    :type (cons can can))
  +  ((alice
  +    :initarg :alice
  +    :initform (error ":alice missing")
  +    :accessor alice-of
  +    :type person)
  +   (bob
  +    :initarg :bob
  +    :initform (error ":bob missing")
  +    :accessor bob-of
  +    :type person)
  +   (a-can
  +    :initarg :a-can
  +    :initform (error ":a-can missing")
  +    :accessor a-can-of
  +    :type can)
  +   (b-can
  +    :initarg :b-can
  +    :initform (error ":b-can missing")
  +    :accessor b-can-of
  +    :type can)
      (wire
  +    :initarg :wire
  +    :initform (error ":wire missing")
       :accessor wire-of
       :type wire)))
   
  
positive.code: 					     (voice->vibration vo)))))
  
  
  (defmethod run ((csp csp-scenario))
    (labels ((run-rec (csp evs)
  	     (if (null evs)
  		 csp
  		 (multiple-value-call #'run-rec
  		   (evolve csp evs)))))
      (with-accessors ((prss persons-of)) csp
        (multiple-value-bind (act evs)
  	  (schedule (car prss) nil
  		    (make-instance 'event
  				   :owner-path (path (car prss))
  				   :time 0
  				   :fn #'think))
  	(setf (car prss) act)
  	(run-rec csp evs)))))
  
negative.code:     (setf tho> (make-instance 'thought-out-port :owner p))))
  
  
  (defmethod initialize-instance :after ((csp csp-scenario) &key)
    (with-accessors ((alice alice-of) (bob bob-of)
  		   (a-can a-can-of) (b-can b-can-of)
  		   (wire wire-of)) csp
      (labels ((set-all (csp comps)
  	       (if (null comps)
  		   csp
  		   (let ((fst (first comps)))
  		     (set-all (update-component csp fst (id-of fst))
  			      (rest comps))))))
        (set-all csp (list alice bob a-can b-can wire))
        ;; setup i/o connections between ports
        ;; alice --voice--> a-can
        (i/o-connect (voice-out-of alice)
  		   (voice-in-of a-can))
        ;; a-can --voice--> alice
        (i/o-connect (voice-out-of a-can)
  		   (voice-in-of alice))
        ;; bob --voice--> b-can
        (i/o-connect (voice-out-of bob)
  		   (voice-in-of b-can))
        ;; b-can --voice--> bob
        (i/o-connect (voice-out-of b-can)
  		   (voice-in-of bob))
        ;; a-can --vibration--> wire
        (i/o-connect (vibration-out-of a-can)
  		   (a-vibration-in-of wire))
        ;; wire --vibration--> a-can
        (i/o-connect (a-vibration-out-of wire)
  		   (vibration-in-of a-can))
        ;; b-can --vibration--> wire
        (i/o-connect (vibration-out-of b-can)
  		   (b-vibration-in-of wire))
        ;; wire --vibration--> b-can
        (i/o-connect (b-vibration-out-of wire)
  		   (vibration-in-of b-can)))))
  
  
  (defun vibration->voice (vi)
    (declare (vibration vi))
    (make-instance 'voice :message (message-of vi)))
  
  
  (defun voice->vibration (vo)
    (declare (voice vo))
    (make-instance 'vibration :message (message-of vo)))
  
  
  
  ;; PERSON BEHAVIOUR
  