On this page: #lang-Specified Code
code Racket Code
schemeid Preserving Comments Code Fonts and Styles
4.3.1 Typesetting Code

The codeblock and code forms (see #lang-Specified Code) typeset code verbatim, adding a layer of color to the code based on the same syntax-coloring parsers that are used by DrRacket. Input that is parsed as an identifier is further given a lexical context and hyperlinked via for-label imports.

The racketblock and racket forms (see Racket Code) typeset S-expression code roughly verbatim, but roughly by quoting the source term with syntax. Identifiers in the quoted S-expression are hyperlinked via for-label imports.

The two different approaches to typesetting code—codeblock and code versus racketbock and rackethave different advantages and disadvantages: #lang-Specified Code

(codeblock option ... str-expr ...+)
option = #:keep-lang-line? keep-expr
  | #:indent indent-expr
  | #:expand expand-expr
  | #:context context-expr
  | #:line-numbers line-number-expr
  keep-expr : any/c
  indent-expr : exact-nonnegative-integer?
  expand-expr : (or/c #f (syntax-object? . -> . syntax-object?))
  context-expr : syntax-object?
  line-number-expr : (or/c #f exact-nonnegative-integer?)
Parses the code formed by the strings produced by the str-exprs as a Racket module (roughly) and produces a block that typesets the code inset via nested with the style 'code-inset.

The str-exprs should normally start with #lang to determine the reader syntax for the module, but the resulting “module” need not expand or compile—except as needed by expand-expr. If expand-expr is omitted or produces false, then the input formed by str-expr is read until an end-of-file is encountered, otherwise a single form is read from the input.

When keep-expr produces a true value (the default), the first line in the input (which is typically #lang) is preserved in the typeset output, otherwise the first line is dropped. The typeset code is indented by the amount specified by indent-expr, which defaults to 0.

When expand-expr produces #f (which is the default), identifiers in the typeset code are colored and linked based on for-label bindings in the lexical environment of the syntax object provided by context-expr. The default context-expr has the same lexical context as the first str-expr. When line-number-expr is true, line number is enabled starting from line-number-expr.

When expand-expr produces a procedure, it is used to macro-expand the parsed program, and syntax coloring is based on the parsed program.

For example,

  #lang scribble/manual
    #lang scribble/manual

produces the typeset result

#lang scribble/manual
  #lang scribble/manual

(codeblock0 option ... str-expr ...+)
Like codeblock, but without the 'code-inset nested wrapper.

(code option ... str-expr ...+)
option = #:lang lang-line-expr
  | #:expand expand-expr
  | #:context context-expr
  lang-line-expr : (or/c #f string?)
  expand-expr : (or/c #f (syntax-object? . -> . syntax-object?))
  context-expr : syntax-object?
Like codeblock, but produces content instead of a block. No #lang line should appear in the string content; instead, it should be provided #:lang (as a string without "#lang ") if needed, and the #lang line is always stripped from the output when provided. Also, each newline in str-exprs is collapsed along with all surrounding whitespace to a single space.

For example,

This is @code[#:lang "at-exp racket"]|{@bold{Hi}}|'s result:

produces the typeset result

This is @bold{Hi}’s result: Hi. Racket Code

(racketblock maybe-escape datum ...)
maybe-escape = 
  | #:escape escape-id
Typesets the datum sequence as a table of Racket code inset inset via nested with the style 'code-inset. The source locations of the datums determine the generated layout. For example,

 (define (loop x)
   (loop (not x))))

produces the output

(define (loop x)
  (loop (not x)))

with the (loop (not x)) indented under define, because that’s the way it is idented the use of racketblock. Source-location span information is used to preserve #true versus #t and #false versus #f, and syntax-object properties are used to preserve square brackets and curly braces versus parentheses; otherwise, using syntax objects tends to normalize the form of S-expression elements.

In the above example, define is typeset as a keyword (in black) and as a hyperlink to define’s definition in the reference manual, because this document was built using a for-label binding of define (in the source) that matches a definition in the reference manual. Similarly, not is a hyperlink to its definition in the reference manual.

Like other forms defined via define-code, racketblock expands identifiers that are bound as element transformers.

An #:escape clause specifies an identifier to escape back to an expression that produces produces an element. But default, the escape identifier is unsyntax. For example,

  (+ 1 #,(elem (racket x) (subscript "2"))))


(+ 1 x2)

The escape-id that defaults to unsyntax is regonized via free-identifier=?, so a binding can hide the escape behavior:

  (let ([unsyntax #f])
      #'(+ 1 #,x))))

The RACKETBLOCK form’s default escape is UNSYNTAX instead of unsyntax.

A few other escapes are recognized symbolically:

See also scribble/comment-reader.

(RACKETBLOCK maybe-escape datum ...)
Like racketblock, but with the default expression escape UNSYNTAX instead of unsyntax.

(racketblock0 maybe-escape datum ...)
Like racketblock, but without insetting the code via nested.

(RACKETBLOCK0 maybe-escape datum ...)
Like RACKETBLOCK, but without insetting the code via nested.

(racketresultblock maybe-escape datum ...)
(racketresultblock0 maybe-escape datum ...)
(RACKETRESULTBLOCK maybe-escape datum ...)
(RACKETRESULTBLOCK0 maybe-escape datum ...)
Like racketblock, etc., but colors the typeset text as a result (i.e., a single color with no hyperlinks) instead of code.

(racketinput maybe-escape datum ...)
(RACKETINPUT maybe-escape datum ...)
Like racketblock and RACKETBLOCK, but the datums are typeset after a prompt representing a REPL.

(racketinput0 maybe-escape datum ...)
(RACKETINPUT0 maybe-escape datum ...)
Like racketinput and RACKETINPUT, but without insetting the code via nested.

(racketmod maybe-file maybe-escape lang datum ...)
maybe-file = 
  | #:file filename-expr
maybe-escape = 
  | #:escape escape-id
Like racketblock, but the datum are typeset inside a #lang-form module whose language is lang.

The source location of lang (relative to the body datums) determines the relative positioning of the #lang line in the typeset output. So, line up lang with the left end of the content code.

If #:file is provided, then the code block is typeset using filebox with filename-expr as the filename argument.

(racketmod0 maybe-file maybe-escape lang datum ...)
Like racketmod, but without insetting the code via nested.

(racket maybe-escape datum ...)
Like racketblock, but typeset on a single line and wrapped with its enclosing paragraph, independent of the formatting of datum.

(RACKET maybe-escape datum ...)
Like racket, but with the UNSYNTAX escape like racketblock.

(racketresult maybe-escape datum ...)
Like racket, but typeset as a result (i.e., a single color with no hyperlinks).

(racketid maybe-escape datum ...)
Like racket, but typeset as an unbound identifier (i.e., no coloring or hyperlinks).

(schemeblock maybe-escape datum ...)
(SCHEMEBLOCK maybe-escape datum ...)
(schemeblock0 maybe-escape datum ...)
(SCHEMEBLOCK0 maybe-escape datum ...)
(schemeinput maybe-escape datum ...)
(schememod lang maybe-escape datum ...)
(scheme maybe-escape datum ...)
(SCHEME maybe-escape datum ...)
(schemeresult maybe-escape datum ...)
(schemeid maybe-escape datum ...)
Compatibility aliases. Each scheme... name is an alias for the corresponding racket... binding. Preserving Comments

 #reader scribble/comment-reader

As a reader module, scribble/comment-reader reads a single S-expression that contains ;-based comment lines, and it wraps the comments with code:comment for use with forms like racketblock. More precisely, scribble/comment-reader extends the current reader to adjust the parsing of ;.

For example, within a Scribble document that imports scribble/manual,

  @#reader scribble/comment-reader


    ;; This is not a pipe




; This is not a pipe

The initial @ is needed above to shift into S-expression mode, so that #reader is recognized as a reader declaration instead of literal text. Also, the example uses (racketblock ....) instead of @racketblock[....] because the @-reader would drop comments within the racketblock before giving scribble/comment-reader a chance to convert them. Code Fonts and Styles

Like racket, but typeset as a module path. If datum is an identifier or expr produces a symbol, then it is hyperlinked to the module path’s definition as created by defmodule.

(racketmodlink datum pre-content-expr ...)
Like racketmod, but separating the module path to link from the content to be linked. The datum module path is always linked, even if it is not an identifier.

(litchar str ...)  element?
  str : string?
Typesets strs as a representation of literal text. Use this when you have to talk about the individual characters in a stream of text, as as when documenting a reader extension.

(racketfont pre-content ...)  element?
  pre-content : pre-content?
Typesets decoded pre-content as uncolored, unhyperlinked Racket. This procedure is useful for typesetting things like #lang, which are not readable by themselves.

(racketvalfont pre-content ...)  element?
  pre-content : pre-content?
Like racketfont, but colored as a value.

(racketresultfont pre-content ...)  element?
  pre-content : pre-content?
Like racketfont, but colored as a REPL result.

(racketidfont pre-content ...)  element?
  pre-content : pre-content?
Like racketfont, but colored as an identifier.

(racketvarfont pre-content ...)  element?
  pre-content : pre-content?
Like racketfont, but colored as a variable (i.e., an argument or sub-form in a procedure being documented).

(racketkeywordfont pre-content ...)  element?
  pre-content : pre-content?
Like racketfont, but colored as a syntactic form name.

(racketparenfont pre-content ...)  element?
  pre-content : pre-content?
Like racketfont, but colored like parentheses.

(racketmetafont pre-content ...)  element?
  pre-content : pre-content?
Like racketfont, but colored as meta-syntax, such as backquote or unquote.

(racketcommentfont pre-content ...)  element?
  pre-content : pre-content?
Like racketfont, but colored as a comment.

(racketerror pre-content ...)  element?
  pre-content : pre-content?
Like racketfont, but colored as error-message text.

(racketmodfont pre-content ...)  element?
  pre-content : pre-content?
Like racketfont, but colored as module name.

(racketoutput pre-content ...)  element?
  pre-content : pre-content?
Like racketfont, but colored as output.

(procedure pre-content ...)  element?
  pre-content : pre-content?
Typesets decoded pre-content as a procedure name in a REPL result (e.g., in typewriter font with a #<procedure: prefix and > suffix.).

(var datum)
Typesets datum as an identifier that is an argument or sub-form in a procedure being documented. Normally, the defproc and defform arrange for racket to format such identifiers automatically in the description of the procedure, but use var if that cannot work for some reason.

(svar datum)
Like var, but for subform non-terminals in a form definition.

(schememodname datum)
(schememodname (unsyntax expr))
(schememodlink datum pre-content-expr ...)
(schemefont pre-content ...)  element?
  pre-content : pre-content?
(schemevalfont pre-content ...)  element?
  pre-content : pre-content?
(schemeresultfont pre-content ...)  element?
  pre-content : pre-content?
(schemeidfont pre-content ...)  element?
  pre-content : pre-content?
(schemevarfont pre-content ...)  element?
  pre-content : pre-content?
(schemekeywordfont pre-content ...)  element?
  pre-content : pre-content?
(schemeparenfont pre-content ...)  element?
  pre-content : pre-content?
(schememetafont pre-content ...)  element?
  pre-content : pre-content?
(schemeerror pre-content ...)  element?
  pre-content : pre-content?
(schememodfont pre-content ...)  element?
  pre-content : pre-content?
(schemeoutput pre-content ...)  element?
  pre-content : pre-content?
Compatibility aliases. Each scheme... name is an alias for the corresponding racket... binding.