anchor.diff:  (defconstant +pipe-read-fd+ 0)
   (defconstant +pipe-write-fd+ 1)
   
  -(defun evaluate-pipe-sequence (sy)
  +(defun evaluate-pipe-sequence (sy pipeline-vector)
     (with-slots (command pipe-sequence-tail) sy
       (cond
         (pipe-sequence-tail
  -       (with-pipe (pipe)
  -         (with-accessors ((read-end read-end) (write-end write-end)) pipe
  -           (shadow-fd-bindings
  -             (bind-fd +pipe-write-fd+ write-end)
  -             (evaluate command))
  -           (shadow-fd-bindings
  -             (bind-fd +pipe-read-fd+ read-end)
  -             (evaluate pipe-sequence-tail)))))
  +       (with-pipe (read-end write-end)
  +         (with-fd-scope ()
  +           (bind-fd +pipe-write-fd+ write-end)
  +           (vector-push-extend (evaluate command) pipeline-vector))
  +         (with-fd-scope ()
  +           (bind-fd +pipe-read-fd+ read-end)
  +           (evaluate-pipe-sequence pipe-sequence-tail pipeline-vector))))
   
         (t
  -       (evaluate command)))))
  +       (vector-push-extend (evaluate command) pipeline-vector)))))
   
   (defmethod evaluate ((sy pipe-sequence))
  -  (evaluate-pipe-sequence sy))
  -(defmethod evaluate ((sy pipe-sequence-tail))
  -  (evaluate-pipe-sequence sy))
  +  (cond
  +    ((slot-value sy 'pipe-sequence-tail)
  +     (let ((pipeline-vector (make-array 0 :adjustable t :fill-pointer t :element-type 'eval-thunk)))
  +       (evaluate-pipe-sequence sy pipeline-vector)
  +       (make-instance 'pipeline-thunk :processes pipeline-vector)))
  +
  +    (t
  +     (evaluate (slot-value sy 'command)))))
   
   (defmethod evaluate ((sy command))
     (with-slots (compound-command redirect-list) sy
  -    (shadow-fd-bindings
  +    (with-fd-scope ()
         (handle-redirect redirect-list)
         (evaluate compound-command))))
   
  
positive.code: (defun process-from-pid (pid)
    (make-instance 'process :pid pid))
  
  (defclass pipeline-process (eval-thunk)
    ((processes)))
  
  (defun separator-par-p (separator)
    (check-type separator separator)
    (with-slots (separator-op) separator
      (when (slot-boundp separator 'separator-op)
        (typep separator-op 'par))))
  
  (defparameter *fd-bindings* (make-hash-table))
  
  (defparameter *fds-to-close-for-shadow* nil)
  
  (defparameter *managed-fds* (make-hash-table))
  (defun fd-is-managed (fd)
    (setf (gethash fd *managed-fds*) t))
  (defun forget-managed-fd (fd)
    (remhash fd *managed-fds*))
  (defun managed-fds ()
    (hash-table-keys *managed-fds*))
  
  (defmacro shadow-fd-bindings (&body body)
    (let ((fd (gensym "FD")))
      `(let ((*fd-bindings* (copy-hash-table *fd-bindings*))
             *fds-to-close-for-shadow*)
         (unwind-protect (progn ,@body)
           (dolist (,fd *fds-to-close-for-shadow*)
             (forget-managed-fd ,fd)
             (sb-posix:close ,fd))))))
  
  (defgeneric open-args-for-redirect (redirect))
  (defmethod open-args-for-redirect ((r less))
  
negative.code:                              (open-args-for-redirect redirect)
                               *umask*)))
        (format *error-output* "OPEN ~A = ~A~%" fd filename)
        (values fd t))))
  (defmethod fd-from-description ((fd integer))
    (values fd nil))
  
  (defun bind-fd (fd description)
    (multiple-value-bind (from-fd needs-close) (fd-from-description description)
      (push (cons fd from-fd) *fd-bindings*)
      (when needs-close
        (autoclose-fd from-fd))))
  
  (define-condition invalid-fd (error)
    ((fd
  