anchor.diff:      "Finds one match in PROCESSES for each item in PATTERNS. Also ensures that
        the same process doesn’t match multiple patterns."
       (if (= (length patterns) (length processes))
  -        (list (mapcar (lambda (pattern)
  -                        (block per-pattern
  -                          (mapc (lambda (process)
  -                                  (let ((subst (match-local pattern process
  -                                                            substitutions)))
  -                                    (when subst
  -                                      (setf substitutions subst)
  -                                      (setf processes (remove process processes))
  -                                      (return-from per-pattern process))))
  -                                processes)
  -                          (error 'unification-failure
  -                                 :format-control "Could not unify ~s with any process in ~s"
  -                                 :format-arguments (list pattern processes))))
  -                      patterns)
  -              substitutions)
  +        (let ((processes
  +               (mapcar (lambda (pattern)
  +                         (block per-pattern
  +                           (mapc (lambda (process)
  +                                   (let ((subst (match-local pattern process
  +                                                             substitutions)))
  +                                     (when subst
  +                                       (setf substitutions subst)
  +                                       (setf processes (remove process processes))
  +                                       (return-from per-pattern process))))
  +                                 processes)
  +                           (error 'unification-failure
  +                                  :format-control "Could not unify ~s with any process in ~s"
  +                                  :format-arguments (list pattern processes))))
  +                       patterns)))
  +          (values substitutions processes))
           (error 'unification-failure
                  :format-control "Can not unify two different length lists: ~s ~s"
                  :format-arguments (list patterns processes)))))
  
positive.code:                       (error 'unification-failure
                               :format-control "Could not unify ~s with any process in ~s"
                               :format-arguments (list pattern processes))))
                    patterns)
            substitutions)))
  
  ;;; FIXME: MATCH* (and the instances in all the process calculi) should return
  ;;;        (VALUES substitutions processes), not (LIST processes substitutions).
  
  (defgeneric match-local (pattern process &optional substitutions)
    (:method ((patterns list) (processes list)
  
negative.code:     ;; FIXME: This should ensure that _all_ processes match, not just enough to
      ;;        satisfy pattern.
      (let ((processes (remove nil
                               (append (multiple-value-bind (subst procs)
                                           (match-local (messages-in pattern)
                                                        (messages-in process)
                                                        substitutions)
                                         (setf substitutions subst)
                                         procs)
                                       (multiple-value-bind (subst procs)
                                           (match-kell (kells-in pattern)
                                                       (kells-in process)
                                                       substitutions)
  