4 Typesetting Racket Code

Beware that if you use read-syntax on a file port, you may have to turn on line counting via port-count-lines! for the code to typeset properly. Also beware that when a source file containing a syntax or quote-syntax form is compiled, source location information is omitted from the compiled syntax object.

Normally, typeset-code is used through the code syntactic form, which works properly with compilation, and that escapes to pict-producing code via unsyntax. See also define-code.

Embedded picts within stx are used directly. Row elements are combined using and operator like htl-append, so use code-align (see below) as necessary to add an ascent to ascentless picts. More precisely, creation of a line of code uses pict-last to determine the end point of the element most recently added to a line; the main effect is that closing parentheses are attached in the right place when a multi-line pict is embedded in stx.

An identifier that starts with _ is italicized in the pict, and the _ is dropped, unless the code-italic-underscore-enabled parameter is set to #f. Also, unless code-scripts-enabled is set to #f, _ and ^ in the middle of a word create superscripts and subscripts, respectively (like TeX); for example foo^4_ok is displayed as the identifier foo with a 4 superscript and an ok subscript.

Further, uses of certain identifiers in stx typeset specially:

• code:blank — produces a space.

• (code:comment s ...) — produces a comment block, with each s on its own line, where each s must be a string or a pict.

• (code:line datum ...) — typesets the datum sequence, which is mostly useful for the top-level sequence, since typeset-code accepts only one argument.

• (code:contract datum ...) — like code:line, but every datum is colored as a comment, and a ; is prefixed to every line.

• (code:template datum ...) — like code:line, but a ; is prefixed to every line.

• $ — typesets as a vertical bar (for no particularly good reason).

For more information, see typeset-code and define-code, since code is defined as

(define-code code typeset-code)

(lambda (s) (text s (current-code-font) ((get-current-code-font-size))))

This procedure is not used to typeset subscripts or other items that require font changes, where current-code-font is used directly.

The resulting code-id syntactic form takes a sequence of datums:

(code-id datum ...)

It produces a pict that typesets the sequence. Source-location information for the datum determines the layout of code in the resulting pict. The code-id is expanded in such a way that source location is preserved during compilation (so typeset-code-id receives a syntax object with source locations intact).

If a datum contains (escape-id expr)—perhaps as #,expr when escape-id is unsyntax—then the expr is evaluated and the result datum is spliced in place of the escape-id form in datum. If the result is not a syntax object, it is given the source location of the escape-id form. A pict value intected this way as a datum is rendered as itself.

If a datum contains (transform-id datum ...) or transform-id for a transform-id that is bound as syntax to a code transformer, then the (transform-id datum ...) or transform-id may be replaced with an escaped expression, depending on the code transformer’s result.

For code transformer created with (make-code-transformer proc), proc takes a syntax object representing the use of an identifier bound to the transformer, and it produces an expression whose value replaces the identifier use within a code form or a form defined via define-code. Like a macro transformer, a code transformer is triggered either by a use of the bound identifier in an “application” position, in which case the transformer receives the entire “application” form, or the identifier by itself can also trigger the transformer. The code transformer’s proc can return #f, in which case the use of the identifier is left untransformed; if the identifier was used in an “application” position, the transformer proc will be called again for the identifier use by itself.

A code transformer produced by (make-code-transformer stx) is equivalent to

(make-code-transformer (lambda (use-stx)

(if (identifier? use-stx)

stx

#f)))

A structure type with the prop:code-transformer property implements a code transformer. The property value must be a procedure of one argument, which receives the structure and returns a procedure that is like a proc passed to make-code-transformer, except that the property value takes the structure instance as an argument before the syntax object to transform.

The code-transformer? predicate returns #t for a value produced by make-code-transformer or for an instance of a structure type with the prop:code-transformer property, #f otherwise.

Meanwhile, runnable-id is bound to a syntax object that wraps the datums in a begin. In this case, _s are removed from the datums, but not the following expression. Thus, an _ identifier is used to comment out an expression from the pict, but have it present in the syntax object for evaluation.

The string-id is bound to a string representation of the code that is in the pict. This string is useful for copying to the clipboard with (send the-clipboard set-clipboard-string string-id 0).