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: (defgeneric match (pattern process &optional substitutions)
    (:method ((pattern pattern) (process list)
              &optional (substitutions (make-empty-environment)))
      (second (match-local (local-message-pattern pattern)
                           process
                           substitutions)))
    (:method ((pattern pattern) (kell kell)
              &optional (substitutions (make-empty-environment)))
      (let ((processes (append (destructuring-bind (procs subst)
                                   (match-list #'match-local
                                               (local-message-pattern pattern)
                                               (messages kell)
                                               substitutions)
                                 (setf substitutions subst)
                                 procs)
                               (destructuring-bind (procs subst)
                                   (match-list #'match-down
                                               (down-message-pattern pattern)
                                               (apply #'compose-hash-tables
  
negative.code: (defun match-list (type-function patterns processes substitutions)
    "Finds one match in PROCESSES for each item in PATTERNS. Also ensures that the
     same process doesn’t match multiple patterns."
    (let* ((matched-processes ())
           (processes
            (mapcar (lambda (pattern)
                      (block per-pattern
                        (mapc (lambda (process)
                                (when (not (find process matched-processes))
  