anchor.diff:      (as-> *empty-shell-readtable* x
         (with-dispatch-character x "$")
         (with-default-handler x "$" 'handle-dollar)
  +      (with-handler x "${" 'handle-dollar-curly)
  +      (with-dispatch-character x "$(")
  +      (with-default-handler x "$(" 'handle-dollar-paren)
  +      (with-handler x "$((" 'handle-dollar-paren-paren)
         (with-handler x "`" 'handle-backtick)))
   
   (define-once-global +double-quote-readtable+
  
positive.code:   (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))
  
negative.code: (defmethod print-object ((command-word command-word) stream)
    (format stream "#<~A ~S>" (class-name (class-of command-word)) (command-word-tokens command-word)))
  
  (defun read-dollar-paren (context)
    ;; We need to parse a full command.  The best way to do that is with
    ;; our `NEXT-TOKEN' function, but that returns tokens instead of
    ;; strings.  We need a string containing everything it read!
    ;; Luckily, an echo stream allows us to know exactly what was read
    ;; by `NEXT-TOKEN'.
    (let ((stream (lexer-context-stream context))
          (out-stream (make-string-output-stream)))
      (format out-stream "$(")
      (let* ((echo-stream (make-echo-stream stream out-stream))
             (token-iterator (token-iterator echo-stream :readtable (lexer-context-readtable context)))
             (tokens (make-extensible-vector)))
  
        (do-iterator (token token-iterator)
          (when (typep token 'rparen)
            (return-from read-dollar-paren (make-instance 'command-word :tokens tokens :value (get-output-stream-string out-stream))))
          (vector-push-extend token tokens))
        (eof-error :comment ") expected")))
    (assert nil nil "This function doesn't return normally"))
  
  (defun read-dollar-paren-paren (stream)
  