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