anchor.diff:    (:method ((process cons) (kell kell))
       (add-process (eval process) kell))
     (:method ((process restriction) (kell kell))
  -    (let ((global-name (gensym (format nil "~a" (name process)))))
  +    (let ((global-name (gensym (format nil "~a-" (name process)))))
         (add-process (apply-restriction (name process) global-name (process process))
                      kell)))
     (:method ((process process) (kell kell))
  
positive.code:       :name (duplicate-process (name process))
        :process (duplicate-process (process process))
        :continuation (duplicate-process (continuation process))))
    (:method ((process trigger))
      (make-instance 'trigger
        :pattern (duplicate-process (pattern process))
        :process (duplicate-process (process process))))
    (:method ((process parallel-composition))
      (let ((pc (make-instance 'parallel-composition)))
        (psetf (messages pc) (mapcar #'duplicate-process (messages process))
               (kells pc) (mapcar #'duplicate-process (kells process))
               (triggers pc) (mapcar #'duplicate-process (triggers process))
               (process-variables pc) (mapcar #'duplicate-process
                                              (process-variables process))
               (primitives pc) (mapcar #'duplicate-process (primitives process)))
        pc))
    (:method ((process restriction))
      (make-instance 'restriction
        :name (duplicate-process (name process))
  
negative.code:   (loop for i from 1 to count
      collecting (make-thread #'run-kiln :name (format nil "kiln ~d" i))))
  
  (defgeneric apply-restriction (local-name global-name process &optional expandp)
    (:documentation "DESTRUCTIVE. Returns the process with all restrictions expanded to
                     have unique names.")
    (:method (local-name global-name process &optional (expandp t))
      (declare (ignore local-name global-name))
      process)
    (:method (local-name global-name (process message) &optional (expandp t))
      (if (eql (name process) local-name)
        (setf (name process) global-name))
      (psetf (process process)
             (apply-restriction local-name global-name (process process) expandp)
             (continuation process)
             (apply-restriction local-name global-name (continuation process) expandp))
      process)
    (:method (local-name global-name (process kell) &optional (expandp t))
      (if (eql (name process) local-name)
        (setf (name process) global-name))
      (psetf (process process)
             (apply-restriction local-name global-name (process process) expandp)
             (continuation process)
             (apply-restriction local-name global-name (continuation process) expandp))
      process)
    (:method (local-name global-name (process parallel-composition) &optional (expandp t))
      (apply #'parallel-composition
             (map-parallel-composition (lambda (proc)
                                         (apply-restriction local-name global-name proc
                                                            expandp))
                                       process)))
    (:method (local-name global-name (process pattern) &optional (expandp t))
      (psetf (local-message-pattern process)
             (mapcar (lambda (message)
                       (apply-restriction local-name global-name message expandp))
                     (local-message-pattern process))
             (down-message-pattern process)
             (mapcar (lambda (message)
                       (apply-restriction local-name global-name message expandp))
                     (down-message-pattern process))
             (up-message-pattern process)
             (mapcar (lambda (message)
                       (apply-restriction local-name global-name message expandp))
                     (up-message-pattern process))
             (kell-message-pattern process)
             (mapcar (lambda (message)
                       (apply-restriction local-name global-name message expandp))
                     (kell-message-pattern process)))
      process)
    (:method (local-name global-name (process restriction) &optional (expandp t))
      (if expandp
        (apply-restriction local-name
                           global-name
                           (apply-restriction (name process)
                                              (gensym (format nil "~a-" (name process)))
                                              (process process)
                                              expandp)
                           expandp)
        (if (eql local-name (name process))
          process
          (progn
            (setf (process process)
                  (apply-restriction local-name global-name (process process) expandp))
            process))))
    (:method (local-name global-name (process trigger) &optional (expandp t))
      (psetf (pattern process)
             (apply-restriction local-name global-name (pattern process) expandp)
             (process process)
             (apply-restriction local-name global-name (process process) nil))
      process))
  
  (defgeneric activate-process (process kell)
  