anchor.diff:    (error 'not-implemented :feature "${}"))
   
   (defun read-dollar-word (stream)
  -  (assert (equal #\$ (read-char stream nil :eof)))
     (let ((next-char (peek-char nil stream nil :eof)))
       (when (or (find next-char #(#\@ #\* #\# #\? #\- #\$ #\!))
                 (digit-char-p next-char))
  
positive.code:                        :value (concatenate 'string "$" (string next-char))))))
    (let ((name (read-name stream)))
      (make-instance 'variable-expansion-word :variable name :value (concatenate 'string "$" name))))
  
  (defun read-dollar (stream)
    (let ((next-char (peek-char nil stream nil :eof)))
      (let ((new-stream (make-concatenated-stream (make-string-input-stream "$") stream)))
        (cond ((equal #\{ next-char)
               (read-dollar-curly new-stream))
  
              ((equal #\( next-char)
               (read-dollar-paren new-stream))
  
              (t
               (read-dollar-word new-stream))))))
  
  (defun read-comment (stream)
    (let ((next-char (peek-char nil stream nil :eof)))
  
negative.code: 
  (defun handle-dollar (stream initiation-sequence context)
    (declare (ignore initiation-sequence))
    (lexer-context-add-part context (read-dollar-word stream))
    t)
  
  (defun handle-dollar-paren (stream initiation-sequence context)
    (declare (ignore stream initiation-sequence))
    (lexer-context-add-part context (read-dollar-paren context))
    t)
  
  (defun handle-dollar-paren-paren (stream initiation-sequence context)
    (declare (ignore initiation-sequence))
    (lexer-context-add-part context (read-dollar-paren-paren stream))
    t)
  
  (defun handle-backtick (stream initiation-sequence context)
  