anchor.diff:    ;;  "This method catches us to avoid infinite recursion."
     ;;  (error "~a is not a valid process." process-b))
     (:method ((process-a parallel-composition) (process-b message))
  -    (push process-b (messages process-a))
  -    process-a)
  +    (let ((pc (make-instance 'parallel-composition)))
  +      (psetf (process-variables pc) (process-variables process-a)
  +             (messages pc) (cons process-b (messages process-a))
  +             (kells pc) (kells process-a)
  +             (triggers pc) (triggers process-a))
  +      pc))
     (:method ((process-a parallel-composition) (process-b kell))
  -    (push process-b (kells process-a))
  -    process-a)
  +    (let ((pc (make-instance 'parallel-composition)))
  +      (psetf (process-variables pc) (process-variables process-a)
  +             (messages pc) (messages process-a)
  +             (kells pc) (cons process-b (kells process-a))
  +             (triggers pc) (triggers process-a))
  +      pc))
     (:method ((process-a parallel-composition) (process-b process-variable))
  -    (push process-b (process-variables process-a))
  -    process-a)
  +    (let ((pc (make-instance 'parallel-composition)))
  +      (psetf (process-variables pc) (cons process-b (process-variables process-a))
  +             (messages pc) (messages process-a)
  +             (kells pc) (kells process-a)
  +             (triggers pc) (triggers process-a))
  +      pc))
     (:method ((process-a parallel-composition) (process-b trigger))
  -    (push process-b (triggers process-a))
  -    process-a))
  +    (let ((pc (make-instance 'parallel-composition)))
  +      (psetf (process-variables pc) (process-variables process-a)
  +             (messages pc) (messages process-a)
  +             (kells pc) (kells process-a)
  +             (triggers pc) (cons process-b (triggers process-a)))
  +      pc)))
   
   #| not sure if we ever need this – annotated messages aren't a thing so much as a category
   (defmethod annotated-messages ((kell kell))
  
positive.code:   (:method (process-a (process-b null-process))
      process-a)
    (:method ((process-a parallel-composition) (process-b parallel-composition))
      (psetf (process-variables process-a)
             (nconc (process-variables process-a) (process-variables process-b))
             (messages process-a)
             (nconc (messages process-a) (messages process-b))
             (kells process-a)
             (nconc (kells process-a) (kells process-b))
             (triggers process-a)
             (nconc (triggers process-a) (triggers process-b)))
      process-a)
    (:method (process-a (process-b parallel-composition))
      "This method just swaps the args so the function is commutatitve."
      (compose-processes process-b process-a))
  
negative.code:   (kells-in (process kell)))
  
  (defgeneric compose-processes (process-a process-b)
    (:documentation
     "Conses up a new parallel composition that contains both process-a and process-b.")
    (:method (process-a process-b)
      (let ((pc (make-instance 'parallel-composition)))
        (compose-processes (compose-processes pc process-a)
  