anchor.diff:        (if (or (not process)
                 (eval-pred predicate rest))
             (let ((next (car rest)))
  -            (sbcl-run-spec next input output error predicate (cdr rest)
  -                           (if (typep next 'sequence-spec)
  -                               r
  -                               resume)))
  +            (generic-run-spec next input output error predicate (cdr rest)
  +                              (if (typep next 'sequence-spec)
  +                                  r
  +                                  resume)))
             (when resume
               (with-slots (predicate rest resume input output error) resume
                 (when (and (consp rest) (consp (cdr rest)))
                   (let ((remainder (cdr rest)))
                     (when (eval-pred predicate remainder)
  -                    (sbcl-run-spec (second rest) input output error
  -                                   predicate (cddr rest) resume))))))))))
  +                    (generic-run-spec (second rest) input output error
  +                                      predicate (cddr rest) resume))))))))))
   
   (defun process-result-list (rl)
     (if (listp rl)
  
positive.code:              (let ((thread (result-thread r)))
                 (when thread
                   (sb-thread:join-thread thread)))))
      (let* ((first-results (sbcl-run-spec spec input output error nil nil nil))
             (full-results (alexandria:flatten (nconc first-results
                                                     (loop :for r :in first-results
                                                        :nconc (process-result-list r))))))
  
negative.code:                                :input input :output r-output :error error
                                 :predicate predicate :rest rest :resume resume))))))
  
  (defun make-pipe ()
    (multiple-value-bind (fd1 fd2) 
        (sb-unix:unix-pipe)
      (values (sb-sys:make-fd-stream fd1 :buffering :none)
              (sb-sys:make-fd-stream fd2 :buffering :none))))
  
  (defun process-wait (p)
    (sb-ext:process-wait p))
  
  (defmethod process-result ((r result))
    (labels ((eval-pred (pred rest)
  