anchor.diff:    t)
   
   (defun handle-dollar (stream initiation-sequence context)
  -  (declare (ignore initiation-sequence))
  -  (lexer-context-add-part context (read-dollar-word stream))
  +  (let ((next-char (lexer-context-next-char context))
  +        name)
  +    (cond
  +      ((or (find next-char #(#\@ #\* #\# #\? #\- #\$ #\!))
  +           (digit-char-p next-char))
  +       (lexer-context-consume-character context)
  +       (let ((part (make-instance 'variable-expansion-word
  +                                  :variable (string next-char)
  +                                  :value (concatenate 'string "$" (string next-char)))))
  +         (lexer-context-add-part context part)))
  +
  +      ((setf name (read-name stream :error-on-invalid-name-p nil))
  +       (let ((part (make-instance 'variable-expansion-word
  +                                  :variable name
  +                                  :value (concatenate 'string "$" name))))
  +         (lexer-context-add-part context part)))
  +
  +      (t
  +       (lexer-context-add-chars context initiation-sequence))))
     t)
   
   (defun handle-dollar-paren (stream initiation-sequence context)
  
positive.code: (defun read-dollar-curly (stream)
    (declare (ignore stream))
    (error 'not-implemented :feature "${}"))
  
  (defun read-dollar-word (stream)
    (let ((next-char (peek-char nil stream nil :eof)))
      (when (or (find next-char #(#\@ #\* #\# #\? #\- #\$ #\!))
                (digit-char-p next-char))
        (read-char stream nil :eof)
        (return-from read-dollar-word
          (make-instance 'variable-expansion-word
                         :variable (string next-char)
                         :value (concatenate 'string "$" (string next-char))))))
    (let ((name (read-name stream)))
      (make-instance 'variable-expansion-word :variable name :value (concatenate 'string "$" name))))
  
  (defun read-comment (stream)
    (let ((next-char (peek-char nil stream nil :eof)))
  
negative.code:                (vector-push-extend next-char result)
                 (read-char stream nil :eof)
                 (setf next-char (peek-char nil stream nil :eof))))
        (unless (non-digit)
          (if error-on-invalid-name-p
              (error "Names can't start with ~S" next-char)
              (return-from read-name nil)))
        (loop :while (and (not (eq :eof next-char)) (any-valid))
           :do (take))
        result)))
  