anchor.diff:      :initform ""
       :accessor not-implemented-message
       :type string)))
  +
  +(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*
     (let ((table (make-hash-table)))
  
positive.code:       (when command-list-tail
          (evaluate command-list-tail)))))
  
  (defmethod evaluate ((sy and-or))
    (with-slots (pipeline and-or-tail) sy
      (evaluate pipeline)
      (when and-or-tail
        (evaluate and-or-tail))))
  
  (defmethod evaluate ((sy pipeline))
    (with-slots (bang pipe-sequence) sy
      (error 'not-implemented :message "! not implemented")))
  
  (defmethod evaluate ((sy pipe-sequence))
    (with-slots (command pipe-sequence-tail) sy
      (when pipe-sequence-tail
        (error 'not-implemented :message "| not implemented"))
      (evaluate command)))
  
  (defmethod evaluate ((sy command))
    (with-slots (compound-command redirect-list) sy
      (shadow-fd-bindings
        (handle-redirect redirect-list)
        (evaluate compound-command))))
  
  (defun cmd-prefix-parts (prefix)
    (with-slots (io-redirect assignment-word cmd-prefix-tail) prefix
  
negative.code: 
           (evaluate command-list))))))
  
  (defun evaluate-command-list (sy)
    (with-slots (and-or command-list-tail) sy
      (let ((no-wait (and command-list-tail
                          (typep (slot-value command-list-tail 'separator-op) 'par))))
  