&{Hello &[name]!}

($string$ "Hello " $<<$ name $>>$ "!")

&{This has a {braced} section.}
  ⇒ "This has a {braced} section."

You can the standard XML syntax for character references, using either decimal or hexadecimal values. The following string has two instances of the Ascii escape character, as either decimal 27 or hex 1B:

&{} ⇒ "\e\e"

You can also use the pre-defined XML entity names:

&{&amp; &lt; &gt; &quot; &apos;} ⇒ "& < > \" '"

In addition, { } can be used for left and right curly brace, though you don’t need them for balanced parentheses:

&{ }_{ / {_} }  ⇒ " }_{ / {_} "

You can use the standard XML entity names. For example:

&{Lærdalsøyri}
  ⇒ "Lærdalsøyri"

You can also use the standard R7RS character names null, alarm, backspace, tab, newline, return, escape, space, and delete. For example:

&{&escape;&space;}

The syntax &name; is actually syntactic sugar (specifically reader syntax) to the variable reference $entity$:name. Hence you can also define your own entity names:

(define $entity$:crnl "\r\n")
&{&crnl;} ⟹ "\r\n"

initial-ignored ::=
    intraline-whitespace* line-ending intraline-whitespace* &|
special-escape ::=
    intraline-whitespace* &|
  | & nested-comment
  | &- intraline-whitespace* line-ending

A line-ending directly in the text is becomes a newline, as in a simple string literal:

(string-capitalize &{one two three
uno dos tres
}) ⇒ "One Two Three\nUno Dos Tres\n"

However, you have extra control over layout. If the string is in a nested expression, it is confusing (and ugly) if the string cannot be indented to match the surrounding context. The indentation marker &| is used to mark the end of insignificant initial whitespace. The &| characters and all the preceding whitespace are removed. In addition, it also suppresses an initial newline. Specifically, when the initial left-brace is followed by optional (invisible) intraline-whitespace, then a newline, then optional intraline-whitespace (the indentation), and finally the indentation marker &| - all of which is removed from the output. Otherwise the &| only removes initial intraline-whitespace on the same line (and itself).

(write (string-capitalize &{
     &|one two three
     &|uno dos tres
}) out)
    ⇒ prints "One Two Three\nUno Dos Tres\n"

As a matter of style, all of the indentation lines should line up. It is an error if there are any non-whitespace characters between the previous newline and the indentation marker. It is also an error to write an indentation marker before the first newline in the literal.

The line-continuation marker &- is used to suppress a newline:

&{abc&-
  def} ⇒ "abc  def"

You can write a #|...|#-style comment following a &. This could be useful for annotation, or line numbers:

&{&#|line 1|#one two
  &#|line 2|# three
  &#|line 3|#uno dos tres
} ⇒ "one two\n three\nuno dos tres\n"

enclosed-part ::=
    & enclosed-modifier* [ expression* ]
  | & enclosed-modifier* ( expression+ )

An embedded expression has the form &[expression]. It is evaluated, the result converted to a string (as by display), and the result added in the result string. (If there are multiple expressions, they are all evaluated and the corresponding strings inserted in the result.)

&{Hello &[(string-capitalize name)]!}

You can leave out the square brackets when the expression is a parenthesized expression:

&{Hello &(string-capitalize name)!}

enclosed-modifier ::=
  ~ format-specifier-after-tilde

Using format allows finer-grained control over the output, but a problem is that the association between format specifiers and data expressions is positional, which is hard-to-read and error-prone. A better solution places the specifier adjacant to the data expression:

&{The response was &~,2f(* 100.0 (/ responses total))%.}

The following escape forms are equivalent to the corresponding forms withput the ~fmt-spec, except the expression(s) are formatted using format:

Again using parentheses like this:

is equivalent to:

The syntax of format specifications is arcane, but it allows you to do some pretty neat things in a compact space. For example to include "_" between each element of the array arr you can use the ~{...~} format speciers:

(define arr [5 6 7])
&{&~{&[arr]&~^_&~}} ⇒ "5_6_7"

If no format is specified for an enclosed expression, the that is equivalent to a ~a format specifier, so this is equivalent to:

&{&~{&~a[arr]&~^_&~}} ⇒ "5_6_7"

which is in turn equivalent to:

(format #f "~{~a~^_~}" arr)

The fine print that makes this work: If there are multiple expressions in a &[...] with no format specifier then there is an implicit ~a for each expression. On the other hand, if there is an explicit format specifier, it is not repeated for each enclosed expression: it appears exactly once in the effective format string, whether there are zero, one, or many expressions.