anchor.diff:    (print-unreadable-object (word stream :type t)
       (format stream "~W = ~W" (assignment-word-name word) (assignment-word-value-word word))))
   
  -(defun make-assignment-word-from-parts (parts raw)
  +(defun make-assignment-word-from-parts (parts &rest initargs)
     (let* ((first-part (aref parts 0))
            (first-word (simple-word-text first-part))
            (name-break-point (assignment-word-p first-word))
  
positive.code:         (raw-stream all-chars consumed-chars last-char-status
                      first-consumed-character-position)
        stream
      (let ((char (if hang-p
                      (read-char raw-stream nil :eof)
                      (read-char-no-hang raw-stream nil :eof))))
        (cond
          ((and (not hang-p)
                (not char)))
          ((eq char :eof)
           (setf last-char-status nil))
          ((lexer-context-consume-p stream)
           (vector-push-extend char all-chars)
           (vector-push-extend char consumed-chars)
           (unless (slot-boundp stream 'first-consumed-character-position)
             (setf first-consumed-character-position (make-position-record-from-positional-stream raw-stream)))
           (setf last-char-status 'consumed))
          (t
           (vector-push-extend char all-chars)
  
negative.code:   (shell-lexer-context-word-boundary context)
    (with-slots (parts consumed-chars) context
      (let* ((part-count (length parts))
             (simple-word (shell-lexer-context-simple-word context))
             (position (lexer-context-first-consumed-character-position context))
             (initargs `(:value ,consumed-chars :position ,position)))
        (cond ((and simple-word
                    (operator-p simple-word))
               (apply 'make-operator simple-word initargs))
  
              ((and simple-word
                    (reserved-p simple-word))
               (apply 'make-reserved simple-word initargs))
  
              ((and simple-word
                    (not (find-if-not #'digit-char-p simple-word))
                    (or (equal #\< (peek-char nil context nil :eof))
                        (equal #\> (peek-char nil context nil :eof))))
               (apply 'make-instance 'io-number :fd (parse-integer simple-word) initargs))
  
              ((and simple-word
                    (name-p simple-word))
               (apply 'make-instance 'name :text simple-word initargs))
  
              ((shell-lexer-context-assignment-p context)
               (apply 'make-assignment-word-from-parts parts initargs))
  
              ((equal 1 part-count)
               (let ((part (aref parts 0)))
                 (setf (token-value part) consumed-chars)
                 (setf (token-position part) position)
                 part))
  
              ((< 1 part-count)
               (apply 'make-instance 'compound-word :parts parts initargs))
  
              ((equal 0 part-count)
               (when (eq :error if-empty)
  