anchor.diff:        (assert (equal #\( next-char))
         (take))))
   
  -(defun read-name (stream)
  +(defun read-name (stream &key (error-on-invalid-name-p nil))
     (let ((next-char (peek-char nil stream nil :eof))
           (result (make-extensible-vector :element-type 'character)))
       (labels ((non-digit ()
  
positive.code:                (vector-push-extend next-char result)
                 (read-char stream nil :eof)
                 (setf next-char (peek-char nil stream nil :eof))))
        (assert (non-digit) nil "Names can't start with ~S" next-char)
        (loop :while (and (not (eq :eof next-char)) (any-valid))
           :do (take))
        result)))
  
negative.code:   t)
  
  (defun handle-dollar (stream initiation-sequence context)
    (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)
  