6.2.1Using the @ Reader

Note that the Scribble reader reads @-forms as S-expressions. This
means that it is up to you to give meanings for these expressions in
the usual way: use Racket functions, define your functions, or require
functions. For example, typing the above into racket is likely
going to produce a “reference to undefined identifier” error, unless
foo is defined. You can use string-append instead,
or you can define foo as a function (with variable arity).

A common use of the Scribble @-reader is when using Scribble as a
documentation system for producing manuals. In this case, the manual
text is likely to start with

which installs the @ reader starting in “text mode,” wraps the
file content afterward into a Racket module where many useful Racket
and documentation related functions are available, and parses the body
into a document using scribble/decode. See
Document Reader for more information.

Another way to use the reader is to use the use-at-readtable
function to switch the current readtable to a readtable that parses
@-forms. You can do this in a single command line:

racket -ile scribble/reader "(use-at-readtable)"

6.2.2Syntax Properties

The Scribble reader attaches properties to syntax objects. These
properties might be useful in some rare situations.

Forms that Scribble reads are marked with a 'scribble
property, and a value of a list of three elements: the first is
'form, the second is the number of items that were read from
the datum part, and the third is the number of items in the body part
(strings, sub-forms, and escapes). In both cases, a 0 means
an empty datum/body part, and #f means that the corresponding
part was omitted. If the form has neither parts, the property is not
attached to the result. This property can be used to give different
meanings to expressions from the datum and the body parts, for
example, implicitly quoted keywords:

In addition, the Scribble parser uses syntax properties to mark syntax
items that are not physically in the original source — indentation
spaces and newlines. Both of these will have a 'scribble
property; an indentation string of spaces will have
'indentation as the value of the property, and a newline will
have a '(newlineS) value where S is the original
newline string including spaces that precede and follow it (which
includes the indentation for the following item). This can be used to
implement a verbatim environment: drop indentation strings, and use
the original source strings instead of the single-newline string. Here
is an example of this.

The idea is that you may want to have completely
different uses for the datum part, for example, introducing a
convenient key=val syntax for attributes.

syntax-post-proc — function that is applied on
each resulting syntax value after it has been parsed (but before it
is wrapped quoting punctuations). You can use this to further
control uses of @-forms, for example, making the command be the
head of a list:

Constructs a variant of a @-readtable. The arguments are the same
as in make-at-readtable, with two more that determine the
kind of reader function that will be created: syntax? chooses
between a read- or read-syntax-like function, and
inside? chooses a plain reader or an -inside
variant.

The resulting function has a different contract and action based on
these inputs. The expected inputs are as in read or
read-syntax depending on syntax?; the function will
read a single expression or, if inside? is true, the whole
input; it will return a syntactic list of expressions rather than a
single one in this case.

Note that syntax? defaults to #t, as this is the
more expected common case when you’re dealing with concrete-syntax
reading.

Note that if syntax? is true, the read-like function
is constructed by simply converting a syntax result back into a datum.