2 The Redex Reference

▼ |  | Redex: Practical Semantics Engineering

1 | Amb: A Redex Tutorial
2 | The Redex Reference
| Index

► | 2 | The Redex Reference

2.1 | Patterns
2.2 | Terms
2.3 | Languages
2.4 | Reduction Relations
2.5 | Other Relations
2.6 | Testing
2.7 | GUI
2.8 | Typesetting

On this page:

2.1`` Patterns
redex-match
redex-match?
match?
match-bindings
bind
caching-enabled?
set-cache-size!
check-redudancy
2.2`` Terms
term
hole
in-hole
term-let
redex-let
redex-let*
define-term
term-match
term-match/ single
plug
variable-not-in
variables-not-in
exn: fail: redex?
2.3`` Languages
define-language
: : =
define-extended-language
define-union-language
language-nts
compiled-lang?
2.4`` Reduction Relations
reduction-relation
extend-reduction-relation
union-reduction-relations
reduction-relation->rule-names
compatible-closure
context-closure
reduction-relation?
apply-reduction-relation
apply-reduction-relation/ tag-with-names
apply-reduction-relation*
current-cache-all?
-->
fresh
with
2.5`` Other Relations
define-metafunction
define-metafunction/ extension
in-domain?
define-judgment-form
define-extended-judgment-form
judgment-holds
build-derivations
derivation
I
O
define-relation
current-traced-metafunctions
2.6`` Testing
test-equal
test-->>
test-->
test-->>∃
test-->>E
test-predicate
test-results
make-coverage
coverage?
relation-coverage
covered-cases
generate-term
redex-check
redex-generator
counterexample
exn: fail: redex: test
check-reduction-relation
check-metafunction
default-attempt-size
default-check-attempts
redex-pseudo-random-generator
exn: fail: redex: generation-failure?
2.7`` GUI
traces
traces/ ps
stepper
stepper/ seed
show-derivations
derivation/ ps
term-node-children
term-node-parents
term-node-labels
term-node-set-color!
term-node-color
term-node-set-red!
term-node-expr
term-node-set-position!
term-node-x
term-node-y
term-node-width
term-node-height
term-node?
reduction-steps-cutoff
initial-font-size
initial-char-width
dark-pen-color
dark-brush-color
light-pen-color
light-brush-color
dark-text-color
light-text-color
pretty-print-parameters
default-pretty-printer
2.8`` Typesetting
2.8.1`` Picts, PDF, & Post Script
render-term
term->pict
render-term/ pretty-write
term->pict/ pretty-write
render-language
language->pict
render-reduction-relation
reduction-relation->pict
render-metafunction
render-metafunctions
metafunction->pict
metafunctions->pict
render-relation
render-judgment-form
relation->pict
judgment-form->pict
2.8.2`` Customization
render-language-nts
extend-language-show-union
render-reduction-relation-rules
rule-pict-style
reduction-rule-style/ c
arrow-space
label-space
metafunction-pict-style
delimit-ellipsis-arguments?
linebreaks
metafunction-cases
judgment-form-cases
label-style
grammar-style
paren-style
literal-style
metafunction-style
non-terminal-style
non-terminal-subscript-style
non-terminal-superscript-style
default-style
label-font-size
metafunction-font-size
default-font-size
reduction-relation-rule-separation
curly-quotes-for-strings
current-text
arrow->pict
set-arrow-pict!
white-bracket-sizing
horizontal-bar-spacing
relation-clauses-combine
2.8.3`` Removing the Pink Background
with-unquote-rewriter
with-atomic-rewriter
with-compound-rewriter
with-compound-rewriters
lw
build-lw
to-lw
to-lw/ stx
render-lw
lw->pict
just-before
just-after

top ← prev up next →

### 2`` The Redex Reference

To load Redex use:

(require redex)

which provides all of the names documented in this library.

Alternatively, use the redex/reduction-semantics and redex/pict modules, which provide only non-GUI functionality (i.e., everything except redex/gui), making them suitable for programs which should not depend on racket/gui/base.

#### 2.1`` Patterns

(require redex/reduction-semantics)

This section covers Redex’s pattern language, used in many of Redex’s forms.

Note that pattern matching is caching (including caching the results of side-conditions). This means that once a pattern has matched a given term, Redex assumes that it will always match that term.

This is the grammar for the Redex pattern language. Non-terminal references are wrapped with angle brackets; otherwise identifiers in the grammar are terminals.

pattern |  | = |  | any
|  | | |  | number
|  | | |  | natural
|  | | |  | integer
|  | | |  | real
|  | | |  | string
|  | | |  | boolean
|  | | |  | variable
|  | | |  | (variable-except <id> ...)
|  | | |  | (variable-prefix <id>)
|  | | |  | variable-not-otherwise-mentioned
|  | | |  | hole
|  | | |  | symbol
|  | | |  | (name <id> <pattern>)
|  | | |  | (in-hole <pattern> <pattern>)
|  | | |  | (hide-hole <pattern>)
|  | | |  | (side-condition <pattern> guard)
|  | | |  | (cross <id>)
|  | | |  | (<pattern-sequence> ...)
|  | | |  | <racket-constant>
pattern-sequence |  | = |  | <pattern>
|  | | |  | ... ; literal ellipsis
|  | | |  | ..._id

- The any pattern matches any sexpression. This pattern may also be suffixed with an underscore and another identifier, in which case they bind the full name (as if it were an implicit name pattern) and match the portion before the underscore.

- The number pattern matches any number. This pattern may also be suffixed with an underscore and another identifier, in which case they bind the full name (as if it were an implicit name pattern) and match the portion before the underscore.

- The natural pattern matches any exact non-negative integer. This pattern may also be suffixed with an underscore and another identifier, in which case they bind the full name (as if it were an implicit name pattern) and match the portion before the underscore.

- The integer pattern matches any exact integer. This pattern may also be suffixed with an underscore and another identifier, in which case they bind the full name (as if it were an implicit name pattern) and match the portion before the underscore.

- The real pattern matches any real number. This pattern may also be suffixed with an underscore and another identifier, in which case they bind the full name (as if it were an implicit name pattern) and match the portion before the underscore.

- The string pattern matches any string. This pattern may also be suffixed with an underscore and another identifier, in which case they bind the full name (as if it were an implicit name pattern) and match the portion before the underscore.

- The boolean pattern matches #true and #false (which are the same as #t and #f, respectively). This pattern may also be suffixed with an underscore and another identifier, in which case they bind the full name (as if it were an implicit name pattern) and match the portion before the underscore.

- The variable pattern matches any symbol. This pattern may also be suffixed with an underscore and another identifier, in which case they bind the full name (as if it were an implicit name pattern) and match the portion before the underscore.

- The variable-except pattern matches any symbol except those listed in its argument. This is useful for ensuring that keywords in the language are not accidentally captured by variables.

- The variable-prefix pattern matches any symbol that begins with the given prefix.

- The variable-not-otherwise-mentioned pattern matches any symbol except those that are used as literals elsewhere in the language.

- The hole pattern matches anything when inside the first argument to an in-hole pattern. Otherwise, it matches only a hole.

- The symbol pattern stands for a literal symbol that must match exactly, unless it is the name of a non-terminal in a relevant language or contains an underscore.

  If it is a non-terminal, it matches any of the right-hand sides of that non-terminal. If the non-terminal appears twice in a single pattern, then the match is constrained to expressions that are the same, unless the pattern is part of a grammar, in which case there is no constraint.

  If the symbol is a non-terminal followed by an underscore, for example e_1, it is implicitly the same as a name pattern that matches only the non-terminal, (name e_1 e) for the example. Accordingly, repeated uses of the same name are constrainted to match the same expression.

  If the symbol is a non-terminal followed by _!_, for example e_!_1, it is also treated as a pattern, but repeated uses of the same pattern are constrained to be different. For example, this pattern:

  > (e_!_1 e_!_1 e_!_1)

  matches lists of three es, but where all three of them are distinct.

  Unlike a _ pattern, the _!_ patterns do not bind names.

  If _ names and _!_ are mixed, they are treated as separate. That is, this pattern (e_1 e_!_1) matches just the same things as (e e), but the second doesn’t bind any variables.

  If the symbol otherwise has an underscore, it is an error.

- The pattern (name symbol pattern) matches pattern and binds using it to the name symbol.

- The (in-hole pattern pattern) pattern matches the first pattern. This match must include exactly one match against the second pattern. If there are zero matches or more than one match, an exception is raised.

  When matching the first argument of in-hole, the hole pattern matches any sexpression. Then, the sexpression that matched the hole pattern is used to match against the second pattern.

- The (hide-hole pattern) pattern matches what the embedded pattern matches but if the pattern matcher is looking for a decomposition, it ignores any holes found in that pattern.

- The (side-condition pattern guard) pattern matches what the embedded pattern matches, and then the guard expression is evaluated. If it returns #f, the pattern fails to match, and if it returns anything else, the pattern matches. Any occurrences of name in the pattern (including those implicitly there via _ pattersn) are bound using term-let in the guard.

- The (cross symbol) pattern is used for the compatible closure functions. If the language contains a non-terminal with the same name as symbol, the pattern (cross symbol) matches the context that corresponds to the compatible closure of that non-terminal.

- The (pattern-sequence ...) pattern matches a sexpression list, where each pattern-sequence element matches an element of the list. In addition, if a list pattern contains an ellipsis, the ellipsis is not treated as a literal, instead it matches any number of duplications of the pattern that came before the ellipses (including 0). Furthermore, each (name symbol pattern) in the duplicated pattern binds a list of matches to symbol, instead of a single match. (A nested duplicated pattern creates a list of list matches, etc.) Ellipses may be placed anywhere inside the row of patterns, except in the first position or immediately after another ellipses.

  Multiple ellipses are allowed. For example, this pattern:

  > ((name x a) ... (name y a) ...)

  matches this sexpression:

  > (term (a a))

  three different ways. One where the first a in the pattern matches nothing, and the second matches both of the occurrences of a, one where each named pattern matches a single a and one where the first matches both and the second matches nothing.

  If the ellipses is named (ie, has an underscore and a name following it, like a variable may), the pattern matcher records the length of the list and ensures that any other occurrences of the same named ellipses must have the same length.

  As an example, this pattern:

  > ((name x a) ..._1 (name y a) ..._1)

  only matches this sexpression:

  > (term (a a))

  one way, with each named pattern matching a single a. Unlike the above, the two patterns with mismatched lengths is ruled out, due to the underscores following the ellipses.

  Also, like underscore patterns above, if an underscore pattern begins with ..._!_, then the lengths must be different.

  Thus, with the pattern:

  > ((name x a) ..._!_1 (name y a) ..._!_1)

  and the expression

  > (term (a a))

  two matches occur, one where x is bound to '() and y is bound to '(a a) and one where x is bound to '(a a) and y is bound to '().

> syntax (redex-match lang pattern any)
> (redex-match lang pattern)

If redex-match receives three arguments, it matches the pattern (in the language) against its third argument. If it matches, this returns a list of match structures describing the matches (see match? and match-bindings). If it fails, it returns #f.

If redex-match receives only two arguments, it builds a procedure for efficiently testing if expressions match the pattern, using the language lang. The procedures accepts a single expression and if the expresion matches, it returns a list of match structures describing the matches. If the match fails, the procedure returns #f.

Examples:
> > (define-language nums
> (AE number
> (+ AE AE)))
> > (redex-match nums
> (+ AE_1 AE_2)
> (term (+ (+ 1 2) 3)))
> (list (match (list (bind 'AE_1 '(+ 1 2)) (bind 'AE_2 3))))
> > (redex-match nums
> (+ AE_1 (+ AE_2 AE_3))
> (term (+ (+ 1 2) 3)))
> #f
> > (redex-match nums
> (+ AE_1 AE_1)
> (term (+ (+ 1 2) 3)))
> #f

> syntax (redex-match? lang pattern any)
> (redex-match? lang pattern)

Like redex-match, except it returns only a boolean indicating if the match was successful.

Examples:
> > (define-language nums
> (AE number
> (+ AE AE)))
> > (redex-match? nums
> (+ AE_1 AE_2)
> (term (+ (+ 1 2) 3)))
> #t
> > (redex-match? nums
> (+ AE_1 AE_1)
> (term (+ (+ 1 2) 3)))
> #t

> procedure (match? val) → boolean?
> val : any/c

Determines if a value is a match structure.

> procedure (match-bindings m) → (listof bind?)
> m : match?

This returns a list of bind structs that binds the pattern variables in this match.

> > struct
> > (struct |  | bind (name exp)
> > |  | #:extra-constructor-name make-bind)
> name : symbol?
> exp : any/c

Instances of this struct are returned by redex-match. Each bind associates a name with an s-expression from the language, or a list of such s-expressions, if the (name ...) clause is followed by an ellipsis. Nested ellipses produce nested lists.

> parameter (caching-enabled?) → boolean?
> (caching-enabled? on?) → void?
> on? : boolean?

When this parameter is #t (the default), Redex caches the results of pattern matching and metafunction evaluation. There is a separate cache for each pattern and metafunction; when one fills (see set-cache-size!), Redex evicts all of the entries in that cache.

Caching should be disabled when matching a pattern that depends on values other than the in-scope pattern variables or evaluating a metafunction that reads or writes mutable external state.

> procedure (set-cache-size! size) → void?
> size : positive-integer?

Changes the size of the per-pattern and per-metafunction caches.

The default size is 350.

> parameter (check-redudancy) → boolean?
> (check-redudancy check?) → void?
> check? : boolean?

Ambiguous patterns can slow down Redex’s pattern matching implementation significantly. To help debug such performance issues, set the check-redundancy parameter to #t. This causes Redex to, at runtime, report any redundant matches that it encounters.

#### 2.2`` Terms

Object language expressions in Redex are written using term. It is similar to Racket’s quote (in many cases it is identical) in that it constructs lists as the visible representation of terms.

The grammar of terms is (note that an ellipsis stands for repetition unless otherwise indicated):

term |  | = |  | identifier
|  | | |  | (term-sequence ...)
|  | | |  | ,racket-expression
|  | | |  | (in-hole term term)
|  | | |  | hole
|  | | |  | #t
|  | | |  | #f
|  | | |  | string
term-sequence |  | = |  | term
|  | | |  | ,@racket-expression
|  | | |  | ... ; literal ellipsis

- A term written identifier is equivalent to the corresponding symbol, unless the identifier is bound by term-let, define-term, or a pattern variable or the identifier is hole (as below).

- A term written (term-sequence ...) constructs a list of the terms constructed by the sequence elements.

- A term written ,racket-expression evaluates the racket-expression and substitutes its value into the term at that point.

- A term written ,@racket-expression evaluates the racket-expression, which must produce a list. It then splices the contents of the list into the expression at that point in the sequence.

- A term written (in-hole tttterm tttterm) is the dual to the pattern in-hole – it accepts a context and an expression and uses plug to combine them.

- A term written hole produces a hole.

- A term written as a literal boolean or a string produces the boolean or the string.

> syntax (term term)
> (term term #:lang lang-id)

Used for construction of a term.

It behaves similarly to quasiquote, except for a few special forms that are recognized (listed below) and that names bound by term-let are implicitly substituted with the values that those names were bound to, expanding ellipses as in-place sublists (in the same manner as syntax-case patterns).

The optional #:lang keyword must supply an identifier bound by define-language, and adds a check that any symbol containing an underscore in term could have been bound by a pattern in the language referenced by lang-id. In practice, this means that the underscore must be preceded by a non-terminal in that langauge or a built-in pattern such as number. This form of term is used internally by default, so this check is applied to terms that are constructed by Redex forms such as reduction-relation and define-metafunction.

For example,

> (term-let ([body '(+ x 1)]
> [(expr ...) '(+ - (values * /))]
> [((id ...) ...) '((a) (b) (c d))])
> (term (let-values ([(id ...) expr] ...) body)))

evaluates to

> '(let-values ([(a) +]
> [(b) -]
> [(c d) (values * /)])
> (+ x 1))

It is an error for a term variable to appear in an expression with an ellipsis-depth different from the depth with which it was bound by term-let. It is also an error for two term-let-bound identifiers bound to lists of different lengths to appear together inside an ellipsis.

> syntax hole

Recognized specially within term. A hole form is an error elsewhere.

> syntax in-hole

Recognized specially within reduction-relation. An in-hole form is an error elsewhere.

> syntax (term-let ([tl-pat expr] ...) body)
> tl-pat |  | = |  | identifier
> |  | | |  | (tl-pat-ele ...)
> tl-pat-ele |  | = |  | tl-pat
> |  | | |  | tl-pat ... ; a literal ellipsis

Matches each given id pattern to the value yielded by evaluating the corresponding expr and binds each variable in the id pattern to the appropriate value (described below). These bindings are then accessible to the term syntactic form.

Note that each ellipsis should be the literal symbol consisting of three dots (and the ... elsewhere indicates repetition as usual). If tl-pat is an identifier, it matches any value and binds it to the identifier, for use inside term. If it is a list, it matches only if the value being matched is a list value and only if every subpattern recursively matches the corresponding list element. There may be a single ellipsis in any list pattern; if one is present, the pattern before the ellipses may match multiple adjacent elements in the list value (possibly none).

This form is a lower-level form in Redex, and not really designed to be used directly. For let-like forms that use Redex’s full pattern matching facilities, see redex-let, redex-let*, term-match, term-match/single.

> syntax (redex-let language ([pattern expression] ...) body ...+)

Like term-let but the left-hand sides are Redex patterns, interpreted according to the specified language. It is a syntax error for two left-hand sides to bind the same pattern variable.

This form raises an exception recognized by exn:fail:redex? if any right-hand side does not match its left-hand side in exactly one way.

In some contexts, it may be more efficient to use term-match/single (lifted out of the context).

> syntax (redex-let* language ([pattern expression] ...) body ...+)

The let* analog of redex-let.

> syntax (define-term identifier term)

Defines identifier for use in term templates.

> syntax (term-match language [pattern expression] ...)

This produces a procedure that accepts term (or quoted) expressions and checks them against each pattern. The function returns a list of the values of the expression where the pattern matches. If one of the patterns matches multiple times, the expression is evaluated multiple times, once with the bindings in the pattern for each match.

When evaluating a term-match expression, the patterns are compiled in an effort to speed up matching. Using the procedural result multiple times to avoid compiling the patterns multiple times.

> syntax (term-match/single language [pattern expression] ...)

This produces a procedure that accepts term (or quoted) expressions and checks them against each pattern. The function returns the expression behind the first sucessful match. If that pattern produces multiple matches, an error is signaled. If no patterns match, an error is signaled.

Raises an exception recognized by exn:fail:redex? if no clauses match or if one of the clauses matches multiple ways.

When evaluating a term-match/single expression, the patterns are compiled in an effort to speed up matching. Using the procedural result multiple times to avoid compiling the patterns multiple times.

> procedure (plug context expression) → any
> context : any/c
> expression : any/c

The first argument to this function is an sexpression to plug into. The second argument is the sexpression to replace in the first argument. It returns the replaced term. This is also used when a term sub-expression contains in-hole.

> procedure (variable-not-in t var) → symbol?
> t : any/c
> var : symbol?

This helper function accepts an sexpression and a variable. It returns a variable not in the sexpression with a prefix the same as the second argument.

> procedure (variables-not-in t vars) → (listof symbol?)
> t : any/c
> vars : (listof symbol?)

This function, like variable-not-in, makes variables that do no occur in its first argument, but it returns a list of such variables, one for each variable in its second argument.

Does not expect the input symbols to be distinct, but does produce variables that are always distinct.

> procedure (exn:fail:redex? v) → boolean?
> v : any/c

Returns #t if its argument is a Redex exception record, and #f otherwise.

#### 2.3`` Languages

> > syntax
> > (define-language lang-name
> > non-terminal-def ...)
> non-terminal-def |  | = |  | (non-terminal-name ...+ ::= pattern ...+)
> |  | | |  | (non-terminal-name pattern ...+)
> |  | | |  | ((non-terminal-name ...+) pattern ...+)

This form defines the grammar of a language. It allows the definition of recursive patterns, much like a BNF, but for regular-tree grammars. It goes beyond their expressive power, however, because repeated name patterns and side-conditions can restrict matches in a context-sensitive way.

A non-terminal-def comprises one or more non-terminal names (considered aliases) followed by one or more productions.

For example, the following defines lc-lang as the grammar of the λ-calculus:

> (define-language lc-lang
> (e (e e ...)
> x
> v)
> (c (v ... c e ...)
> hole)
> (v (λ (x ...) e))
> (x variable-not-otherwise-mentioned))

with non-terminals e for the expression language, x for variables, c for the evaluation contexts and v for values.

> syntax ::=

A non-terminal’s names and productions may be separated by the keyword ::=. Use of the ::= keyword outside a language definition is a syntax error.

> > syntax
> > (define-extended-language extended-lang base-lang
> > non-terminal-def ...)
> non-terminal-def |  | = |  | (non-terminal-name ...+ ::= pattern ...+)
> |  | | |  | (non-terminal-name pattern ...+)
> |  | | |  | ((non-terminal-name ...+) pattern ...+)

This form extends a language with some new, replaced, or extended non-terminals. For example, this language:

> (define-extended-language lc-num-lang
> lc-lang
> (v .... ; extend the previous `v' non-terminal
> number
> +)
> (x (variable-except λ +)))

extends lc-lang with two new alternatives (+ and number) for the v non-terminal, carries forward the e and c non-terminals, and replaces the x non-terminal with a new one (which happens to be equivalent to the one that would have been inherited).

The four-period ellipses indicates that the new language’s non-terminal has all of the alternatives from the original language’s non-terminal, as well as any new ones. If a non-terminal occurs in both the base language and the extension, the extension’s non-terminal replaces the originals. If a non-terminal only occurs in either the base language, then it is carried forward into the extension. And, of course, extend-language lets you add new non-terminals to the language.

If a language is has a group of multiple non-terminals defined together, extending any one of those non-terminals extends all of them.

> syntax (define-union-language L base/prefix-lang ...)
> base/prefix-lang |  | = |  | lang-id
> |  | | |  | (prefix lang-id)

Constructs a language that is the union of all of the languages listed in the base/prefix-lang.

If the two languages have non-terminals in common, then define-union-language will combine all of the productions of the common non-terminals. For example, this definition of L:

> (define-language L1
> (e ::=
> (+ e e)
> number))
> (define-language L2
> (e ::=
> (if e e e)
> true
> false))
> (define-union-language L L1 L2)

is equivalent to this one:

> (define-language L
> (e ::=
> (+ e e)
> number
> (if e e e)
> true
> false))

If a language has a prefix, then all of the non-terminals from that language have the corresponding prefix in the union language. The prefix helps avoid unintended collisions between the constituent language’s non-terminals.

For example, with two these two languages:

> (define-language UT
> (e (e e)
> (λ (x) e)
> x))
> (define-language WT
> (e (e e)
> (λ (x t) e)
> x)
> (t (→ t t)
> num))

then this declaration:

> (define-union-language B (ut. UT) (wt. WT))

will create a language named B containing the non-terminals ut.e, wt.e, and wt.t consisting of the productions listed in the original languages.

> procedure (language-nts lang) → (listof symbol?)
> lang : compiled-lang?

Returns the list of non-terminals (as symbols) that are defined by this language.

> procedure (compiled-lang? l) → boolean?
> l : any/c

Returns #t if its argument was produced by language, #f otherwise.

#### 2.4`` Reduction Relations

> > syntax
> > (reduction-relation language domain base-arrow
> > reduction-case ...
> > shortcuts)
> domain |  | = |  |
> |  | | |  | #:domain pattern
> base-arrow |  | = |  |
> |  | | |  | #:arrow base-arrow-name
> reduction-case |  | = |  | (arrow-name pattern term red-extras ...)
> red-extras |  | = |  | rule-name
> |  | | |  | (fresh fresh-clause ...)
> |  | | |  | (side-condition racket-expression)
> |  | | |  | (where pattern term)
> |  | | |  | (judgment-holds (judgment-form-id pat/term ...))
> |  | | |  | (side-condition/hidden racket-expression)
> |  | | |  | (where/hidden pattern term)
> shortcuts |  | = |  |
> |  | | |  | with shortcut ...
> shortcut |  | = |  |
> [(old-arrow-name pattern term)
> (new-arrow-name identifier identifier)]
> rule-name |  | = |  | identifier
> |  | | |  | string
> |  | | |  | (computed-name racket-expression)
> fresh-clause |  | = |  | var
> |  | | |  | ((var1 ...) (var2 ...))
> pat/term |  | = |  | pattern
> |  | | |  | term

Defines a reduction relation casewise, one case for each of the reduction-case clauses.

The optional domain clause provides a contract for the relation, in the form of a pattern that defines the relation’s domain and codomain.

The arrow-name in each reduction-case clause is either base-arrow-name (default -->) or an arrow name defined by shortcuts (described below). In either case, the pattern refers to language and binds variables in the corresponding term. Following the pattern and term can be the name of the reduction rule and declarations of fresh variables and side-conditions.

For example, the expression

> (reduction-relation
> lc-lang
> (--> (in-hole c_1 ((λ (variable_i ...) e_body) v_i ...))
> (in-hole c_1 ,(foldl lc-subst
> (term e_body)
> (term (v_i ...))
> (term (variable_i ...))))
> beta-v))

defines a reduction relation for the lc-lang grammar.

A rule’s name (used in typesetting, the stepper, traces, and apply-reduction-relation/tag-with-names) can be given as a literal (an identifier or a string) or as an expression that computes a name using the values of the bound pattern variables (much like the rule’s right-hand side). Some operations require literal names, so a rule definition may provide both a literal name and a computed name. In particular, only rules that include a literal name may be replaced using extend-reduction-relation, used as breakpoints in the stepper, and selected using render-reduction-relation-rules. The output of apply-reduction-relation/tag-with-names, traces, and the stepper prefers the computed name, if it exists. Typesetting a rule with a computed name shows the expression that computes the name only when the rule has no literal name or when it would not typeset in pink due to with-unquote-rewriters in the context; otherwise, the literal name (or nothing) is shown.

Fresh variable clauses generate variables that do not occur in the term being reduced. If the fresh-clause is a variable, that variable is used both as a binding in the term and as the prefix for the freshly generated variable. (The variable does not have to be a non-terminal in the language of the reduction relation.)

The second form of fresh-clauses generates a sequence of variables. In that case, the ellipses are literal ellipses; that is, you must actually write ellipses in your rule. The variable var1 is like the variable in first case of a fresh-clause; namely it is used to determine the prefix of the generated variables and it is bound in the right-hand side of the reduction rule, but unlike the single-variable fresh clause, it is bound to a sequence of variables. The variable var2 is used to determine the number of variables generated and var2 must be bound by the left-hand side of the rule.

The expressions within side-condition clauses and side-condition/hidden clauses are collected with and and used as guards on the case being matched. The argument to each side-condition should be a Racket expression, and the pattern variables in the pattern are bound in that expression. A side-condition/hidden clause is the same as a side-condition clause, except that the condition is not rendered when typesetting via redex/pict.

Each where clause acts as a side condition requiring a successful pattern match, and it can bind pattern variables in the side-conditions (and where clauses) that follow and in the metafunction result. The bindings are the same as bindings in a term-let expression. A where/hidden clause is the same as a where clause, but the clause is not rendered when typesetting via redex/pict.

Each judgment-holds clause acts like a where clause, where the left-hand side pattern incorporates each of the patterns used in the judgment form’s output positions.

Each shortcut clause defines arrow names in terms of base-arrow-name and earlier shortcut definitions. The left- and right-hand sides of a shortcut definition are identifiers, not patterns and terms. These identifiers need not correspond to non-terminals in language.

For example, this expression

> (reduction-relation
> lc-num-lang
> (==> ((λ (variable_i ...) e_body) v_i ...)
> ,(foldl lc-subst
> (term e_body)
> (term (v_i ...))
> (term (variable_i ...))))
> (==> (+ number_1 ...)
> ,(apply + (term (number_1 ...))))
> with
> [(--> (in-hole c_1 a) (in-hole c_1 b))
> (==> a b)])

defines reductions for the λ-calculus with numbers, where the ==> shortcut is defined by reducing in the context c.

A fresh clause in reduction-case defined by shortcut refers to the entire term, not just the portion matched by the left-hand side of shortcut’s use.

> syntax (extend-reduction-relation reduction-relation language more ...)

This form extends the reduction relation in its first argument with the rules specified in more. They should have the same shape as the rules (including the with clause) in an ordinary reduction-relation.

If the original reduction-relation has a rule with the same name as one of the rules specified in the extension, the old rule is removed.

In addition to adding the rules specified to the existing relation, this form also reinterprets the rules in the original reduction, using the new language.

> procedure (union-reduction-relations r ...) → reduction-relation?
> r : reduction-relation?

Combines all of the argument reduction relations into a single reduction relation that steps when any of the arguments would have stepped.

> procedure (reduction-relation->rule-names r) → (listof symbol?)
> r : reduction-relation?

Returns the names of the reduction relation’s named clauses.

> syntax (compatible-closure reduction-relation lang non-terminal)

This accepts a reduction, a language, the name of a non-terminal in the language and returns the compatible closure of the reduction for the specified non-terminal.

> syntax (context-closure reduction-relation lang pattern)

This accepts a reduction, a language, a pattern representing a context (ie, that can be used as the first argument to in-hole; often just a non-terminal) in the language and returns the closure of the reduction in that context.

> procedure (reduction-relation? v) → boolean?
> v : any/c

Returns #t if its argument is a reduction-relation, and #f otherwise.

> procedure (apply-reduction-relation r t) → (listof any/c)
> r : reduction-relation?
> t : any/c

This accepts reduction relation, a term, and returns a list of terms that the term reduces to.

> > procedure
> > (apply-reduction-relation/tag-with-names |  | r |
> > |  | t) |
> → (listof (list/c (union false/c string?) any/c))
> r : reduction-relation?
> t : any/c

Like apply-reduction-relation, but the result indicates the names of the reductions that were used.

> > procedure
> > (apply-reduction-relation* |  | r |
> > |  | t |
> > | [ | #:cache-all? cache-all? |
> > |  | #:stop-when stop-when]) |
> → (listof any/c)
> r : reduction-relation?
> t : any/c
> cache-all? : boolean? = (current-cache-all?)
> stop-when : (-> any/c any) = (λ (x) #f)

Accepts a reduction relation and a term. Starting from t, it follows every reduction path and returns all of the terms that do not reduce further. If there are infinite reduction sequences that do not repeat, this function will not terminate (it does terminate if the only infinite reduction paths are cyclic).

If the cache-all? argument is #t, then apply-reduction-relation* keeps a cache of all visited terms when traversing the graph and does not revisit any of them. This cache can, in some cases, use a lot of memory, so it is off by default and the cycle checking happens by keeping track only of the current path it is traversing through the reduction graph.

The stop-when argument controls the stopping criterion. Specifically, it is called with each term that apply-reduction-relation* encounters. If it ever returns a true value (anything except #f), then apply-reduction-relation* considers the term to be irreducible (and so returns it and does not try to reduce it further).

> parameter (current-cache-all?) → boolean?
> (current-cache-all? cache-all?) → void?
> cache-all? : boolean?

Controls the behavior of apply-reduction-relation* and test-->>’s cycle checking. See apply-reduction-relation* for more details.

Examples:
> > (define-language empty-lang)
> > (define R
> (reduction-relation
> empty-lang
> (--> 0 1)
> (--> 0 2)
> (--> 2 3)
> (--> 3 3)))
> > (apply-reduction-relation R 0)
> '(2 1)
> > (apply-reduction-relation* R 0)
> '(1)

> syntax -->

Recognized specially within reduction-relation. A --> form is an error elsewhere.

> syntax fresh

Recognized specially within reduction-relation. A fresh form is an error elsewhere.

> syntax with

Recognized specially within reduction-relation. A with form is an error elsewhere.

#### 2.5`` Other Relations

> > syntax
> > (define-metafunction language
> > metafunction-contract
> > [(name pattern ...) term metafunction-extras ...]
> > ...)
> metafunction-contract |  | = |  |
> id : pattern-sequence ... -> range
> maybe-pre-condition
> maybe-pre-condition |  | = |  | #:pre term
> range |  | = |  | pattern
> |  | | |  | pattern or range
> |  | | |  | pattern ∨ range
> |  | | |  | pattern ∪ range
> metafunction-extras |  | = |  | (side-condition racket-expression)
> |  | | |  | (side-condition/hidden racket-expression)
> |  | | |  | (where pat term)
> |  | | |  | (where/hidden pat term)
> (judgment-holds
> (judgment-form-id pat/term ...))
> |  | | |  | (clause-name name)

The define-metafunction form builds a function on sexpressions according to the pattern and right-hand-side expressions. The first argument indicates the language used to resolve non-terminals in the pattern expressions. Each of the rhs-expressions is implicitly wrapped in term.

The contract, if present, is matched against every input to the metafunction and, if the match fails, an exception is raised. If present, the term inside the maybe-pre-condition is evaluated after a successful match to the input pattern in the contract (with any variables from the input contract bound). If it returns #f, then the input contract is considered to not have matched and an error is also raised.

The side-condition, hidden-side-condition, where, and where/hidden clauses behave as in the reduction-relation form.

The resulting metafunction raises an exception recognized by exn:fail:redex? if no clauses match or if one of the clauses matches multiple ways (and that leads to different results for the different matches).

The side-condition extra is evaluated after a successful match to the corresponding argument pattern. If it returns #f, the clause is considered not to have matched, and the next one is tried. The side-condition/hidden extra behaves the same, but is not typeset.

The where and where/hidden extra are like side-condition and side-condition/hidden, except the match guards the clause.

The judgment-holds clause is like side-condition and where, except the given judgment must hold for the clause to be taken.

The clause-name is used only when typesetting. See metafunction-cases.

Note that metafunctions are assumed to always return the same results for the same inputs, and their results are cached, unless caching-enabled? is set to #f. Accordingly, if a metafunction is called with the same inputs twice, then its body is only evaluated a single time.

As an example, these metafunctions finds the free variables in an expression in the lc-lang above:

> (define-metafunction lc-lang
> free-vars : e -> (x ...)
> [(free-vars (e_1 e_2 ...))
> (∪ (free-vars e_1) (free-vars e_2) ...)]
> [(free-vars x) (x)]
> [(free-vars (λ (x ...) e))
> (- (free-vars e) (x ...))])

The first argument to define-metafunction is the grammar (defined above). Following that are three cases, one for each variation of expressions (e in lc-lang). The free variables of an application are the free variables of each of the subterms; the free variables of a variable is just the variable itself, and the free variables of a λ expression are the free variables of the body, minus the bound parameters.

Here are the helper metafunctions used above.

> (define-metafunction lc-lang
> ∪ : (x ...) ... -> (x ...)
> [(∪ (x_1 ...) (x_2 ...) (x_3 ...) ...)
> (∪ (x_1 ... x_2 ...) (x_3 ...) ...)]
> [(∪ (x_1 ...))
> (x_1 ...)]
> [(∪) ()])
> (define-metafunction lc-lang
> - : (x ...) (x ...) -> (x ...)
> [(- (x ...) ()) (x ...)]
> [(- (x_1 ... x_2 x_3 ...) (x_2 x_4 ...))
> (- (x_1 ... x_3 ...) (x_2 x_4 ...))
> (side-condition (not (memq (term x_2) (term (x_3 ...)))))]
> [(- (x_1 ...) (x_2 x_3 ...))
> (- (x_1 ...) (x_3 ...))])

Note the side-condition in the second case of -. It ensures that there is a unique match for that case. Without it, (term (- (x x) x)) would lead to an ambiguous match.

> > syntax
> > (define-metafunction/extension f language
> > metafunction-contract
> > [(g pattern ...) term metafunction-extras ...]
> > ...)

Defines a metafunction g as an extension of an existing metafunction f. The metafunction g behaves as if f’s clauses were appended to its definition (with occurrences of f changed to g in the inherited clauses).

For example, define-metafunction/extension may be used to extend the free-vars function above to the forms introduced by the language lc-num-lang.

> (define-metafunction/extension free-vars lc-num-lang
> free-vars-num : e -> (x ...)
> [(free-vars-num number)
> ()]
> [(free-vars-num (+ e_1 e_2))
> (∪ (free-vars-num e_1)
> (free-vars-num e_2))])

> syntax (in-domain? (metafunction-name term ...))

Returns #t if the inputs specified to metafunction-name are legtimate inputs according to metafunction-name’s contract, and #f otherwise.

> > syntax
> > (define-judgment-form language
> > mode-spec
> > contract-spec
> > rule rule ...)
> mode-spec |  | = |  | #:mode (form-id pos-use ...)
> contract-spec |  | = |  |
> |  | | |  | #:contract (form-id pattern-sequence ...)
> pos-use |  | = |  | I
> |  | | |  | O
> rule |  | = |  |
> [premise
> ...
> dashes rule-name
> conclusion]
> [conclusion
> premise
> ...
> rule-name]
> conclusion |  | = |  | (form-id pat/term ...)
> premise |  | = |  | (judgment-form-id pat/term ...) maybe-ellipsis
> |  | | |  | (where pattern term)
> |  | | |  | (where/hidden pattern term)
> |  | | |  | (side-condition term)
> |  | | |  | (side-condition/hidden term)
> rule-name |  | = |  |
> |  | | |  | string
> |  | | |  | non-ellipsis-non-hypens-var
> pat/term |  | = |  | pattern
> |  | | |  | term
> maybe-ellipsis |  | = |  |
> |  | | |  | ...
> dashes |  | = |  | ---
> |  | | |  | ----
> |  | | |  | -----
> |  | | |  | etc.

Defines form-id as a relation on terms via a set of inference rules. Each rule must be such that its premises can be evaluated left-to-right without “guessing” values for any of their pattern variables. Redex checks this property using the mandatory mode-spec declaration, which partitions positions into inputs I and outputs O. Output positions in conclusions and input positions in premises must be terms; input positions in conclusions and output positions in premises must be patterns. When the optional contract-spec declaration is present, Redex dynamically checks that the terms flowing through these positions match the provided patterns, raising an exception recognized by exn:fail:redex if not.

For example, the following defines addition on natural numbers:

> > (define-language nats
> (n ::= z (s n)))
> > (define-judgment-form nats
> #:mode (sum I I O)
> #:contract (sum n n n)
> [----------- "zero"
> (sum z n n)]
> [(sum n_1 n_2 n_3)
> ------------------------- "add1"
> (sum (s n_1) n_2 (s n_3))])

The judgment-holds form checks whether a relation holds for any assignment of pattern variables in output positions.

Examples:
> > (judgment-holds (sum (s (s z)) (s z) (s (s (s z)))))
> #t
> > (judgment-holds (sum (s (s z)) (s z) (s (s (s n)))))
> #t
> > (judgment-holds (sum (s (s z)) (s z) (s (s (s (s n))))))
> #f

Alternatively, this form constructs a list of terms based on the satisfying pattern variable assignments.

Examples:
> > (judgment-holds (sum (s (s z)) (s z) (s (s (s n)))) n)
> '(z)
> > (judgment-holds (sum (s (s z)) (s z) (s (s (s (s n))))) n)
> '()
> > (judgment-holds (sum (s (s z)) (s z) (s (s (s n)))) (s n))
> '((s z))

Declaring different modes for the same inference rules enables different forms of computation. For example, the following mode allows judgment-holds to compute all pairs with a given sum.

> > (define-judgment-form nats
> #:mode (sumr O O I)
> #:contract (sumr n n n)
> [------------
> (sumr z n n)]
> [(sumr n_1 n_2 n_3)
> --------------------------
> (sumr (s n_1) n_2 (s n_3))])
> > (judgment-holds (sumr n_1 n_2 (s (s z))) (n_1 n_2))
> '(((s (s z)) z) ((s z) (s z)) (z (s (s z))))

A rule’s where and where/hidden premises behave as in reduction-relation and define-metafunction.

Examples:
> > (define-judgment-form nats
> #:mode (le I I)
> #:contract (le n n)
> [--------
> (le z n)]
> [(le n_1 n_2)
> --------------------
> (le (s n_1) (s n_2))])
> > (define-metafunction nats
> pred : n -> n or #f
> [(pred z) #f]
> [(pred (s n)) n])
> > (define-judgment-form nats
> #:mode (gt I I)
> #:contract (gt n n)
> [(where n_3 (pred n_1))
> (le n_2 n_3)
> ----------------------
> (gt n_1 n_2)])
> > (judgment-holds (gt (s (s z)) (s z)))
> #t
> > (judgment-holds (gt (s z) (s z)))
> #f

A rule’s side-condition and side-condition/hidden premises are similar to those in reduction-relation and define-metafunction, except that they do not implicitly unquote their right-hand sides. In other words, a premise of the form (side-condition term) is equivalent to the premise (where #t term), except it does not typeset with the “#t = ”, as that would.

Judgments with exclusively I mode positions may also be used in terms in a manner similar to metafunctions, and evaluate to a boolean.

Examples:
> > (term (le (s z) (s (s z))))
> #t
> > (term (le (s z) z))
> #f

A literal ellipsis may follow a judgment premise when a template in one of the judgment’s input positions contains a pattern variable bound at ellipsis-depth one.

Examples:
> > (define-judgment-form nats
> #:mode (even I)
> #:contract (even n)
> [-------- "evenz"
> (even z)]
> [(even n)
> ---------------- "even2"
> (even (s (s n)))])
> > (define-judgment-form nats
> #:mode (all-even I)
> #:contract (all-even (n ...))
> [(even n) ...
> ------------------
> (all-even (n ...))])
> > (judgment-holds (all-even (z (s (s z)) z)))
> #t
> > (judgment-holds (all-even (z (s (s z)) (s z))))
> #f

Redex evaluates premises depth-first, even when it doing so leads to non-termination. For example, consider the following definitions:

> > (define-language vertices
> (v a b c))
> > (define-judgment-form vertices
> #:mode (edge I O)
> #:contract (edge v v)
> [(edge a b)]
> [(edge b c)])
> > (define-judgment-form vertices
> #:mode (path I I)
> #:contract (path v v)
> [----------
> (path v v)]
> [(path v_2 v_1)
> --------------
> (path v_1 v_2)]
> [(edge v_1 v_2)
> (path v_2 v_3)
> --------------
> (path v_1 v_3)])

Due to the second path rule, the follow query fails to terminate:

> > (judgment-holds (path a c))

The "examples" directory demonstrates three use cases:

- "typing-rules.rkt" — defines a type system in a way that supports mechanized typesetting. When a typing judgment form can be given a mode, it can also be encoded as a metafunction using where clauses as premises, but Redex cannot typeset that encoding as inference rules.

- "sos.rkt" — defines an SOS-style semantics in a way that supports mechanized typesetting.

- "multi-val.rkt" — defines a judgment form that serves as a multi-valued metafunction.

> > syntax
> > (define-extended-judgment-form language judgment-form-id
> > option ...
> > rule ...)

Defines a new judgment form that extends judgment-form-id with additional rules. The options and rules are as in define-judgment-form.

The mode specification in this judgment form and the original must be the same.

> syntax (judgment-holds judgment)
> (judgment-holds judgment term)
> judgment |  | = |  | (judgment-form-id pat/term ...)

In its first form, checks whether judgment holds for any assignment of the pattern variables in judgment-id’s output positions. In its second form, produces a list of terms by instantiating the supplied term template with each satisfying assignment of pattern variables. See define-judgment-form for examples.

> syntax (build-derivations judgment)

Constructs all of the derivation trees for judgment.

Example:
> > (build-derivations (even (s (s z))))
> (list
> (derivation
> '(even (s (s z)))
> "even2"
> (list (derivation '(even z) "evenz" '()))))

> > struct
> > (struct |  | derivation (term name subs)
> > |  | #:extra-constructor-name make-derivation)
> term : any/c
> name : (or/c string? #f)
> subs : (listof derivation?)

Represents a derivation from a judgment form.

The term field holds an s-expression based rendering of the conclusion of the derivation, the name field holds the name of the clause with term as the conclusion, and subs contains the sub-derivations.

See also build-derivations.

> syntax I

Recognized specially within define-judgment-form, the I keyword is an error elsewhere.

> syntax O

Recognized specially within define-judgment-form, the O keyword is an error elsewhere.

> > syntax
> > (define-relation language
> > relation-contract
> > [(name pattern ...)
> > term ...
> > metafunction-extras ...] ...)
> relation-contract |  | = |  |
> |  | | |  | form-id ⊂ pattern x ... x pattern
> |  | | |  | form-id ⊆ pattern × ... × pattern

Similar to define-judgment-form but suitable only when every position is an input. There is no associated form corresponding to judgment-holds; querying the result uses the same syntax as metafunction application.

The contract specification for a relation restricts the patterns that can be used as input to a relation. For each argument to the relation, there should be a single pattern, using x or × to separate the argument contracts.

Examples:
> > (define-language types
> ((τ σ) int
> num
> (τ → τ)))
> > (define-relation types
> subtype ⊆ τ × τ
> [(subtype int num)]
> [(subtype (τ_1 → τ_2) (σ_1 → σ_2))
> (subtype σ_1 τ_1)
> (subtype τ_2 σ_2)]
> [(subtype τ τ)])
> > (term (subtype int num))
> #t
> > (term (subtype (int → int) (num → num)))
> #f
> > (term (subtype (num → int) (num → num)))
> #t

> parameter (current-traced-metafunctions) → (or/c 'all (listof symbol?))
> (current-traced-metafunctions traced-metafunctions) → void?
> traced-metafunctions : (or/c 'all (listof symbol?))

Controls which metafunctions are currently being traced. If it is 'all, all of them are. Otherwise, the elements of the list name the metafunctions to trace.

The tracing looks just like the tracing done by the racket/trace library, except that the first column printed by each traced call indicate if this call to the metafunction is cached. Specifically, a c is printed in the first column if the result is just returned from the cache and a space is printed if the metafunction call is actually performed.

Defaults to '().

#### 2.6`` Testing

> syntax (test-equal e1 e2)

Tests to see if e1 is equal to e2.

> syntax (test-->> rel-expr option ... e1-expr e2-expr ...)
> option |  | = |  | #:cycles-ok
> |  | | |  | #:equiv pred-expr
> |  | | |  | #:pred pred-expr
> > | rel-expr |  | : |  | reduction-relation?
> > | pred-expr |  | : |  | (--> any/c any)
> > | e1-expr |  | : |  | any/c
> > | e2-expr |  | : |  | any/c

Tests to see if the term e1-expr, reduces to the terms e2-expr under rel-expr, using pred-expr to determine equivalence.

If #:pred is specified, it is applied to each reachable term until one of the terms fails to satify the predicate (i.e., the predicate returns #f). If that happens, then the test fails and a message is printed with the term that failed to satisfy the predicate.

This test uses apply-reduction-relation*, so it does not terminate when the resulting reduction graph is infinite, although it does terminate if there are cycles in the (finite) graph.

If #:cycles-ok is not supplied then any cycles detected are treated as a test failure. If a pred-expr is supplied, then it is used to compare the expected and actual results.

> syntax (test--> rel-expr option ... e1-expr e2-expr ...)
> option |  | = |  | #:equiv pred-expr
> > | rel-expr |  | : |  | reduction-relation?
> > | pred-expr |  | : |  | (--> any/c any/c any/c)
> > | e1-expr |  | : |  | any/c
> > | e2-expr |  | : |  | any/c

Tests to see if the term e1-expr, reduces to the terms e2-expr in a single rel-expr step, using pred-expr to determine equivalence.

Examples:
> > (define-language L
> (i integer))
> > (define R
> (reduction-relation
> L
> (--> i i)
> (--> i ,(add1 (term i)))))
> > (define (mod2=? i j)
> (= (modulo i 2) (modulo j 2)))
> > (test--> R #:equiv mod2=? 7 1)
> FAILED :46.0
> expected: 1
> actual: 8
> actual: 7
> > (test--> R #:equiv mod2=? 7 1 0)
> > (test-results)
> 1 test failed (out of 2 total).

> syntax (test-->>∃ option ... rel-expr start-expr goal-expr)
> option |  | = |  | #:steps steps-expr
> > | rel-expr |  | : |  | reduction-relation?
> > | start-expr |  | : |  | any/c
> > | goal-expr |  | : |  |
> > (or/c (-> any/c any/c)
> > (not/c procedure?))
> > | steps-expr |  | : |  | (or/c natural-number/c +inf.0)

Tests to see if the term start-expr reduces according to the reduction relation rel-expr to a term specified by goal-expr in steps-expr or fewer steps (default 1,000). The specification goal-expr may be either a predicate on terms or a term itself.

> syntax test-->>E

An alias for test-->>∃.

Examples:
> > (define-language L
> (n natural))
> > (define succ-mod8
> (reduction-relation
> L
> (--> n ,(modulo (add1 (term n)) 8))))
> > (test-->>∃ succ-mod8 6 2)
> > (test-->>∃ succ-mod8 6 even?)
> > (test-->>∃ succ-mod8 6 8)
> FAILED :53.0
> term 8 not reachable from 6
> > (test-->>∃ #:steps 6 succ-mod8 6 5)
> FAILED :54.0
> term 5 not reachable from 6 (within 6 steps)
> > (test-results)
> 2 tests failed (out of 4 total).

> syntax (test-predicate p? e)

Tests to see if the value of e matches the predicate p?.

> procedure (test-results) → void?

Prints out how many tests passed and failed, and resets the counters so that next time this function is called, it prints the test results for the next round of tests.

> syntax (make-coverage subject)
> subject |  | = |  | metafunction
> |  | | |  | relation-expr

Constructs a structure (recognized by coverage?) to contain per-case test coverage of the supplied metafunction or reduction relation. Use with relation-coverage and covered-cases.

> procedure (coverage? v) → boolean?
> v : any/c

Returns #t for a value produced by make-coverage and #f for any other.

> parameter (relation-coverage) → (listof coverage?)
> (relation-coverage tracked) → void?
> tracked : (listof coverage?)

Redex populates the coverage records in tracked (default null), counting the times that tests exercise each case of the associated metafunction and relations.

> procedure (covered-cases c) → (listof (cons/c string? natural-number/c))
> c : coverage?

Extracts the coverage information recorded in c, producing an association list mapping names (or source locations, in the case of metafunctions or unnamed reduction-relation cases) to application counts.

Examples:
> > (define-language empty-lang)
> > (define-metafunction empty-lang
> [(plus number_1 number_2)
> ,(+ (term number_1) (term number_2))])
> > (define equals
> (reduction-relation
> empty-lang
> (--> (+) 0 "zero")
> (--> (+ number) number)
> (--> (+ number_1 number_2 number ...)
> (+ (plus number_1 number_2)
> number ...)
> "add")))
> > (let ([equals-coverage (make-coverage equals)]
> [plus-coverage (make-coverage plus)])
> (parameterize ([relation-coverage (list equals-coverage
> plus-coverage)])
> (apply-reduction-relation* equals (term (+ 1 2 3)))
> (values (covered-cases equals-coverage)
> (covered-cases plus-coverage))))
> '(("#f:58:0" . 1) ("add" . 2) ("zero" . 0))
> '(("#f:57:0" . 2))

> syntax (generate-term term-spec size-expr kw-args ...)
> (generate-term term-spec)
> term-spec |  | = |  | language pattern
> |  | | |  | language #:satisfying (judgment-form-id pattern ...)
> |  | | |  | language #:satisfying (metafunction-id pattern ...) = pattern
> |  | | |  | #:source metafunction
> |  | | |  | #:source relation-expr
> kw-args |  | = |  | #:attempt-num attempts-expr
> |  | | |  | #:retries retries-expr
> > | size-expr |  | : |  | natural-number/c
> > | attempt-num-expr |  | : |  | natural-number/c
> > | retries-expr |  | : |  | natural-number/c

In its first form, generate-term produces a random term according to term-spec:

- In the first term-spec case, the produced term matches the given pattern (interpreted according to the definition of the given language).

- In the second case, the expression produced is the quoted form of a use of the judgment-form or #f, if Redex cannot find one.

- The third cases generates a random term that satsifies the call to the metafunction with the given result or #f, if Redex cannot find one.

- In the last two cases, the produced term matches one of the clauses of the specified metafunction or reduction relation.

In generate-term’s second form, it produces a procedure for constructing terms according to term-spec. This procedure expects size-expr (below) as its sole positional argument and allows the same optional keyword arguments as the first form. The second form may be more efficient when generating many terms.

The argument size-expr bounds the height of the generated term (measured as the height of its parse tree).

Examples:
> > (define-language L
> (n number))
> > (generate-term L (+ n_1 n_2) 5)
> '(+ 0 2)
> > (define R
> (reduction-relation
> L
> (--> (one-clause n) ())
> (--> (another-clause n) ())))
> > (random-seed 0)
> > (generate-term #:source R 5)
> '(another-clause 2)
> > (define R-left-hand-sides
> (generate-term #:source R))
> > (R-left-hand-sides 0)
> '(one-clause 1)
> > (R-left-hand-sides 1)
> '(another-clause 1)
> > (define-metafunction L
> [(F one-clause n) ()]
> [(F another-clause n) ()])
> > (generate-term #:source F 5)
> '(another-clause 2)

The optional keyword argument attempt-num-expr (default 1) provides coarse grained control over the random decisions made during generation; increasing attempt-num-expr tends to increase the complexity of the result. For example, the absolute values of numbers chosen for integer patterns increase with attempt-num-expr.

The random generation process does not actively consider the constraints imposed by side-condition or _!_ patterns; instead, it uses a “guess and check” strategy in which it freely generates candidate terms then tests whether they happen to satisfy the constraints, repeating as necessary. The optional keyword argument retries-expr (default 100) bounds the number of times that generate-term retries the generation of any pattern. If generate-term is unable to produce a satisfying term after retries-expr attempts, it raises an exception recognized by exn:fail:redex:generation-failure?.

> syntax (redex-check language pattern property-expr kw-arg ...)
> kw-arg |  | = |  | #:attempts attempts-expr
> |  | | |  | #:source metafunction
> |  | | |  | #:source relation-expr
> |  | | |  | #:retries retries-expr
> |  | | |  | #:print? print?-expr
> |  | | |  | #:attempt-size attempt-size-expr
> |  | | |  | #:prepare prepare-expr
> > | property-expr |  | : |  | any/c
> > | attempts-expr |  | : |  | natural-number/c
> > | relation-expr |  | : |  | reduction-relation?
> > | retries-expr |  | : |  | natural-number/c
> > | print?-expr |  | : |  | any/c
> > | attempt-size-expr |  | : |  | (-> natural-number/c natural-number/c)
> > | prepare-expr |  | : |  | (-> any/c any/c)

Searches for a counterexample to property-expr, interpreted as a predicate universally quantified over the pattern variables bound by pattern. redex-check constructs and tests a candidate counterexample by choosing a random term t that matches pattern then evaluating property-expr using the match-bindings produced by matching t against pattern.

redex-check generates at most attempts-expr (default (default-check-attempts)) random terms in its search. The size and complexity of these terms tend to increase with each failed attempt. The #:attempt-size keyword determines the rate at which terms grow by supplying a function that bounds term size based on the number of failed attempts (see generate-term’s size-expr argument). By default, the bound grows according to the default-attempt-size function.

When print?-expr produces any non-#f value (the default), redex-check prints the test outcome on current-output-port. When print?-expr produces #f, redex-check prints nothing, instead

- returning a counterexample structure when the test reveals a counterexample,

- returning #t when all tests pass, or

- raising a exn:fail:redex:test when checking the property raises an exception.

The optional #:prepare keyword supplies a function that transforms each generated example before redex-check checks property-expr. This keyword may be useful when property-expr takes the form of a conditional, and a term chosen freely from the grammar is unlikely to satisfy the conditional’s hypothesis. In some such cases, the prepare keyword can be used to increase the probability that an example satifies the hypothesis.

When passed a metafunction or reduction relation via the optional #:source argument, redex-check distributes its attempts across the left-hand sides of that metafunction/relation by using those patterns, rather than pattern, as the basis of its generation. It is an error if any left-hand side generates a term that does not match pattern.

Examples:
> > (define-language empty-lang)
> > (random-seed 0)
> > (redex-check
> empty-lang
> ((number_1 ...)
> (number_2 ...))
> (equal? (reverse (append (term (number_1 ...))
> (term (number_2 ...))))
> (append (reverse (term (number_1 ...)))
> (reverse (term (number_2 ...))))))
> redex-check: counterexample found after 5 attempts:
> ((1 0) (0))
> > (redex-check
> empty-lang
> ((number_1 ...)
> (number_2 ...))
> (equal? (reverse (append (term (number_1 ...))
> (term (number_2 ...))))
> (append (reverse (term (number_2 ...)))
> (reverse (term (number_1 ...)))))
> #:attempts 200)
> redex-check: no counterexamples in 200 attempts
> > (let ([R (reduction-relation
> empty-lang
> (--> (Σ) 0)
> (--> (Σ number) number)
> (--> (Σ number_1 number_2 number_3 ...)
> (Σ ,(+ (term number_1) (term number_2))
> number_3 ...)))])
> (redex-check
> empty-lang
> (Σ number ...)
> (printf "~s\n" (term (number ...)))
> #:attempts 3
> #:source R))
> ()
> (1)
> (3 0)
> redex-check: no counterexamples in 1 attempt (with each clause)
> > (redex-check
> empty-lang
> number
> (begin
> (printf "checking ~s\n" (term number))
> (positive? (term number)))
> #:prepare (λ (n)
> (printf "preparing ~s; " n)
> (add1 (abs n)))
> #:attempts 3)
> preparing 0; checking 1
> preparing 0; checking 1
> preparing 1; checking 2
> redex-check: no counterexamples in 3 attempts

> syntax (redex-generator language-id satisfying size-expr)
> satisfying |  | = |  | (judgment-form-id pattern ...)
> |  | | |  | (metafunction-id pattern ...) = pattern
> | size-expr |  | : |  | natural-number/c

WARNING: redex-generator is a new, experimental form, and its API may change.

Returns a thunk that, each time it is called, either generates a random s-expression based on satisfying or fails to (and returns #f). The terms returned by a particular thunk are guaranteed to be distinct.

Examples:
> > (define gen-sum (redex-generator nats (sum n_1 n_2 n_3) 5))
> > (gen-sum)
> '(sum z (s z) (s z))
> > (gen-sum)
> '(sum (s z) z (s z))
> > (gen-sum)
> '(sum (s (s (s (s (s z))))) z (s (s (s (s (s z))))))
> > (gen-sum)
> '(sum (s (s (s (s z)))) z (s (s (s (s z)))))

> > struct
> > (struct |  | counterexample (term)
> > |  | #:extra-constructor-name make-counterexample
> > |  | #:transparent)
> term : any/c

Produced by redex-check, check-reduction-relation, and check-metafunction when testing falsifies a property.

> > struct
> > (struct |  | exn:fail:redex:test exn:fail:redex (source term)
> > |  | #:extra-constructor-name make-exn:fail:redex:test)
> source : exn:fail?
> term : any/c

Raised by redex-check, check-reduction-relation, and check-metafunction when testing a property raises an exception. The exn:fail:redex:test-source component contains the exception raised by the property, and the exn:fail:redex:test-term component contains the term that induced the exception.

> syntax (check-reduction-relation relation property kw-args ...)
> kw-arg |  | = |  | #:attempts attempts-expr
> |  | | |  | #:retries retries-expr
> |  | | |  | #:print? print?-expr
> |  | | |  | #:attempt-size attempt-size-expr
> |  | | |  | #:prepare prepare-expr
> > | property |  | : |  | (-> any/c any/c)
> > | attempts-expr |  | : |  | natural-number/c
> > | retries-expr |  | : |  | natural-number/c
> > | print?-expr |  | : |  | any/c
> > | attempt-size-expr |  | : |  | (-> natural-number/c natural-number/c)
> > | prepare-expr |  | : |  | (-> any/c any/c)

Tests relation as follows: for each case of relation, check-reduction-relation generates attempts random terms that match that case’s left-hand side and applies property to each random term.

This form provides a more convenient notation for

> (redex-check L any (property (term any))
> #:attempts (* n attempts)
> #:source relation)

when relation is a relation on L with n rules.

> syntax (check-metafunction metafunction property kw-args ...)
> kw-arg |  | = |  | #:attempts attempts-expr
> |  | | |  | #:retries retries-expr
> |  | | |  | #:print? print?-expr
> |  | | |  | #:attempt-size attempt-size-expr
> |  | | |  | #:prepare prepare-expr
> > | property |  | : |  | (-> (listof any/c) any/c)
> > | attempts-expr |  | : |  | natural-number/c
> > | retries-expr |  | : |  | natural-number/c
> > | print?-expr |  | : |  | any/c
> > | attempt-size-expr |  | : |  | (-> natural-number/c natural-number/c)
> > | prepare-expr |  | : |  | (-> (listof any/c) (listof any/c))

Like check-reduction-relation but for metafunctions. check-metafunction calls property with lists containing arguments to the metafunction. Similarly, prepare-expr produces and consumes argument lists.

Examples:
> > (define-language empty-lang)
> > (define-metafunction empty-lang
> Σ : number ... -> number
> [(Σ) 0]
> [(Σ number) number]
> [(Σ number_1 number_2) ,(+ (term number_1) (term number_2))]
> [(Σ number_1 number_2 ...) (Σ number_1 (Σ number_2 ...))])
> > (check-metafunction Σ (λ (args)
> (printf "trying ~s\n" args)
> (equal? (apply + args)
> (term (Σ ,@args))))
> #:attempts 2)
> trying ()
> trying ()
> trying (0)
> trying (0)
> trying (2 1)
> trying (0 1)
> trying (0)
> trying (1)
> check-metafunction: no counterexamples in 2 attempts (with each clause)

> procedure (default-attempt-size n) → natural-number/c
> n : natural-number/c

The default value of the #:attempt-size argument to redex-check and the other randomized testing forms, this procedure computes an upper bound on the size of the next test case from the number of previously attempted tests n. Currently, this procedure computes the base 5 logarithm, but that behavior may change in future versions.

> parameter (default-check-attempts) → natural-number/c
> (default-check-attempts attempts) → void?
> attempts : natural-number/c

Determines the default value for redex-check’s optional #:attempts argument. By default, attempts is 1,000.

> parameter (redex-pseudo-random-generator) → pseudo-random-generator?
> (redex-pseudo-random-generator generator) → void?
> generator : pseudo-random-generator?

generate-term and the randomized testing forms (e.g., redex-check) use the parameter generator to construct random terms. The parameter’s initial value is (current-pseudo-random-generator).

> procedure (exn:fail:redex:generation-failure? v) → boolean?
> v : any/c

Recognizes the exceptions raised by generate-term, redex-check, etc. when those forms are unable to produce a term matching some pattern.

Debugging PLT Redex Programs

It is easy to write grammars and reduction rules that are subtly wrong. Typically such mistakes result in examples that get stuck when viewed in a traces window.

The best way to debug such programs is to find an expression that looks like it should reduce, but doesn’t, then try to find out which pattern is failing to match. To do so, use the redex-match form.

In particular, first check if the term in question matches the your system’s main non-terminal (typically the expression or program non-terminal). If it does not match, simplify the term piece by piece to determine whether the problem is in the term or the grammar.

If the term does match your system’s main non-terminal, determine by inspection which reduction rules should apply. For each such rule, repeat the above term-pattern debugging procedure, this time using the rule’s left-hand side pattern instead of the system’s main non-terminal. In addition to simplifying the term, also consider simplifying the pattern.

If the term matches the left-hand side, but the rule does not apply, then one of the rule’s side-condition or where clauses is not satisfied. Using the bindings reported by redex-match, check each side-condition expression and each where pattern-match to discover which clause is preventing the rule’s application.

#### 2.7`` GUI

(require redex/gui)

This section describes the GUI tools that Redex provides for exploring reduction sequences.

> > procedure
> > (traces |  | reductions |
> > |  | expr |
> > | [ | #:multiple? multiple? |
> > |  | #:pred pred |
> > |  | #:pp pp |
> > |  | #:colors colors |
> > |  | #:racket-colors? racket-colors? |
> > |  | #:scheme-colors? scheme-colors? |
> > |  | #:filter term-filter |
> > |  | #:x-spacing x-spacing |
> > |  | #:y-spacing y-spacing |
> > |  | #:layout layout |
> > |  | #:edge-labels? edge-labels? |
> > |  | #:edge-label-font edge-label-font |
> > |  | #:graph-pasteboard-mixin graph-pasteboard-mixin]) |
> → void?
> reductions : reduction-relation?
> expr : (or/c any/c (listof any/c))
> multiple? : boolean? = #f
> | pred |  | : |  |
> (or/c (-> sexp any)
> (-> sexp term-node? any))
> |  | = |  | (λ (x) #t)
> | pp |  | : |  |
> (or/c (any -> string)
> (any output-port number (is-a?/c text%) -> void))
> |  |  | = |  | default-pretty-printer
> | colors |  | : |  |
> (listof
> (cons/c string?
> (and/c (listof (or/c string? (is-a?/c color%)))
> (λ (x) (<= 0 (length x) 6)))))
> |  |  | = |  | '()
> racket-colors? : boolean? = #t
> scheme-colors? : boolean? = racket-colors?
> | term-filter |  | : |  | (-> any/c (or/c #f string?) any/c)
> |  |  | = |  | (λ (x y) #t)
> x-spacing : number? = 15
> y-spacing : number? = 15
> layout : (-> (listof term-node?) void?) = void
> edge-labels? : boolean? = #t
> edge-label-font : (or/c #f (is-a?/c font%)) = #f
> | graph-pasteboard-mixin |  | : |  | (make-mixin-contract graph-pasteboard<%>)
> |  |  | = |  | values

This function opens a new window and inserts each expression in expr (if multiple? is #t – if multiple? is #f, then expr is treated as a single expression). Then, it reduces the terms until at least reduction-steps-cutoff (see below) different terms are found, or no more reductions can occur. It inserts each new term into the gui. Clicking the reduce button reduces until reduction-steps-cutoff more terms are found.

The pred function indicates if a term has a particular property. If it returns #f, the term is displayed with a pink background. If it returns a string or a color% object, the term is displayed with a background of that color (using the-color-database to map the string to a color). If it returns any other value, the term is displayed normally. If the pred function accepts two arguments, a term-node corresponding to the term is passed to the predicate. This lets the predicate function explore the (names of the) reductions that led to this term, using term-node-children, term-node-parents, and term-node-labels.

The pred function may be called more than once per node. In particular, it is called each time an edge is added to a node. The latest value returned determines the color.

The pp function is used to specially print expressions. It must either accept one or four arguments. If it accepts one argument, it will be passed each term and is expected to return a string to display the term.

If the pp function takes four arguments, it should render its first argument into the port (its second argument) with width at most given by the number (its third argument). The final argument is the text where the port is connected – characters written to the port go to the end of the editor.

The colors argument, if provided, specifies a list of reduction-name/color-list pairs. The traces gui will color arrows drawn because of the given reduction name with the given color instead of using the default color.

The cdr of each of the elements of colors is a list of colors, organized in pairs. The first two colors cover the colors of the line and the border around the arrow head, the first when the mouse is over a graph node that is connected to that arrow, and the second for when the mouse is not over that arrow. Similarly, the next colors are for the text drawn on the arrow and the last two are for the color that fills the arrow head. If fewer than six colors are specified, the specified colors are used and then defaults are filled in for the remaining colors.

The racket-colors? argument (along with scheme-colors?, retained for backward compatibility), controls the coloring of each window. When racket-colors? is #t (and scheme-colors? is #t too), traces colors the contents according to DrRacket’s Racket-mode color scheme; otherwise, traces uses a black color scheme.

The term-filter function is called each time a new node is about to be inserted into the graph. If the filter returns false, the node is not inserted into the graph.

The x-spacing and y-spacing control the amount of space put between the snips in the default layout.

The layout argument is called (with all of the terms) when new terms are inserted into the window. In general, it is called after new terms are inserted in response to the user clicking on the reduce button, and after the initial set of terms is inserted. See also term-node-set-position!.

If edge-labels? is #t (the default), then edge labels are drawn; otherwise not.

The edge-label-font argument is used as the font on the edge labels. If #f is suppled, the dc<%> object’s default font is used.

The traces library uses an instance of the mrlib/graph library’s graph-pasteboard<%> interface to layout the graphs. Sometimes, overriding one of its methods can help give finer-grained control over the layout, so the graph-pasteboard-mixin is applied to the class before it is instantiated. Also note that all of the snips inserted into the editor by this library have a get-term-node method which returns the snip’s term-node.

> > procedure
> > (traces/ps |  | reductions |
> > |  | expr |
> > |  | file |
> > | [ | #:multiple? multiple? |
> > |  | #:pred pred |
> > |  | #:pp pp |
> > |  | #:colors colors |
> > |  | #:filter term-filter |
> > |  | #:layout layout |
> > |  | #:x-spacing x-spacing |
> > |  | #:y-spacing y-spacing |
> > |  | #:edge-labels? edge-labels? |
> > |  | #:edge-label-font edge-label-font |
> > |  | #:graph-pasteboard-mixin graph-pasteboard-mixin] |
> > |  | #:post-process post-process) |
> → void?
> reductions : reduction-relation?
> expr : (or/c any/c (listof any/c))
> file : (or/c path-string? path?)
> multiple? : boolean? = #f
> | pred |  | : |  |
> (or/c (-> sexp any)
> (-> sexp term-node? any))
> |  | = |  | (λ (x) #t)
> | pp |  | : |  |
> (or/c (any -> string)
> (any output-port number (is-a?/c text%) -> void))
> |  |  | = |  | default-pretty-printer
> | colors |  | : |  |
> (listof
> (cons/c string?
> (and/c (listof (or/c string? (is-a?/c color%)))
> (λ (x) (<= 0 (length x) 6)))))
> |  |  | = |  | '()
> | term-filter |  | : |  | (-> any/c (or/c #f string?) any/c)
> |  |  | = |  | (λ (x y) #t)
> layout : (-> (listof term-node?) void?) = void
> x-spacing : number? = 15
> y-spacing : number? = 15
> edge-labels? : boolean? = #t
> edge-label-font : (or/c #f (is-a?/c font%)) = #f
> | graph-pasteboard-mixin |  | : |  | (make-mixin-contract graph-pasteboard<%>)
> |  |  | = |  | values
> post-process : (-> (is-a?/c graph-pasteboard<%>) any/c)

This function behaves just like the function traces, but instead of opening a window to show the reduction graph, it just saves the reduction graph to the specified file.

All of the arguments behave like the arguments to traces, with the exception of the post-process argument. It is called just before the PostScript is created with the graph pasteboard.

> procedure (stepper reductions t [pp]) → void?
> reductions : reduction-relation?
> t : any/c
> | pp |  | : |  |
> (or/c (any -> string)
> (any output-port number (is-a?/c text%) -> void))
> |  |  | = |  | default-pretty-printer

This function opens a stepper window for exploring the behavior of the term t in the reduction system given by reductions.

The pp argument is the same as to the traces function but is here for backwards compatibility only and should not be changed for most uses, but instead adjusted with pretty-print-parameters. Specifically, the highlighting shown in the stepper window can be wrong if default-pretty-printer does not print sufficiently similarly to how pretty-print prints (when adjusted by pretty-print-parameters’s behavior, of course).

> procedure (stepper/seed reductions seed [pp]) → void?
> reductions : reduction-relation?
> seed : (cons/c any/c (listof any/c))
> | pp |  | : |  |
> (or/c (any -> string)
> (any output-port number (is-a?/c text%) -> void))
> |  |  | = |  | default-pretty-printer

Like stepper, this function opens a stepper window, but it seeds it with the reduction-sequence supplied in seed.

> > procedure
> > (show-derivations |  | derivations |  |  |  |
> > | [ | #:pp pp |  |  |  |
> > |  | #:racket-colors? racket-colors? |  |  |  |
> > |  | #:init-derivation init-derivation]) |  | → |  | any
> derivations : (cons/c derivation? (listof derivation?))
> | pp |  | : |  |
> (or/c (any -> string)
> (any output-port number (is-a?/c text%) -> void))
> |  |  | = |  | default-pretty-printer
> racket-colors? : boolean? = #f
> init-derivation : exact-nonnegative-integer? = 0

Opens a window to show derivations.

The pp and racket-colors? arguments are like those to traces.

The initial derivation shown in the window is chosen by init-derivation, used as an index into derivations.

> > procedure
> > (derivation/ps |  | derivation |  |  |  |
> > |  | filename |  |  |  |
> > | [ | #:pp pp |  |  |  |
> > |  | #:racket-colors? racket-colors?] |  |  |  |
> > |  | #:post-process post-process) |  | → |  | void?
> derivation : derivation?
> filename : path-string?
> | pp |  | : |  |
> (or/c (any -> string)
> (any output-port number (is-a?/c text%) -> void))
> |  |  | = |  | default-pretty-printer
> racket-colors? : boolean? = #f
> post-process : (-> (is-a?/c pasteboard%) any)

Like show-derivations, except it prints a single derivation in PostScript to filename.

> procedure (term-node-children tn) → (listof term-node?)
> tn : term-node?

Returns a list of the children (ie, terms that this term reduces to) of the given node.

Note that this function does not return all terms that this term reduces to – only those that are currently in the graph.

> procedure (term-node-parents tn) → (listof term-node?)
> tn : term-node?

Returns a list of the parents (ie, terms that reduced to the current term) of the given node.

Note that this function does not return all terms that reduce to this one – only those that are currently in the graph.

> procedure (term-node-labels tn) → (listof (or/c false/c string?))
> tn : term-node?

Returns a list of the names of the reductions that led to the given node, in the same order as the result of term-node-parents. If the list contains #f, that means that the corresponding step does not have a label.

> procedure (term-node-set-color! tn color) → void?
> tn : term-node?
> color : (or/c string? (is-a?/c color%) false/c)

Changes the highlighting of the node; if its second argument is #f, the coloring is removed, otherwise the color is set to the specified color% object or the color named by the string. The color-database<%> is used to convert the string to a color% object.

> procedure (term-node-color tn) → (or/c string? (is-a?/c color%) false/c)
> tn : term-node?

Returns the current highlighting of the node. See also term-node-set-color!.

> procedure (term-node-set-red! tn red?) → void?
> tn : term-node?
> red? : boolean?

Changes the highlighting of the node; if its second argument is #t, the term is colored pink, if it is #f, the term is not colored specially.

> procedure (term-node-expr tn) → any
> tn : term-node?

Returns the expression in this node.

> procedure (term-node-set-position! tn x y) → void?
> tn : term-node?
> x : (and/c real? positive?)
> y : (and/c real? positive?)

Sets the position of tn in the graph to (x,y).

> procedure (term-node-x tn) → real?
> tn : term-node?

Returns the x coordinate of tn in the window.

> procedure (term-node-y tn) → real?
> tn : term-node?

Returns the y coordinate of tn in the window.

> procedure (term-node-width tn) → real?
> tn : term-node?

Returns the width of tn in the window.

> procedure (term-node-height tn) → real?
> tn : term-node?

Returns the height of tn in the window.

> procedure (term-node? v) → boolean?
> v : any/c

Recognizes term nodes.

> parameter (reduction-steps-cutoff) → number?
> (reduction-steps-cutoff cutoff) → void?
> cutoff : number?

A parameter that controls how many steps the traces function takes before stopping.

> parameter (initial-font-size) → number?
> (initial-font-size size) → void?
> size : number?

A parameter that controls the initial font size for the terms shown in the GUI window.

> parameter (initial-char-width) → (or/c number? (-> any/c number?))
> (initial-char-width width) → void?
> width : (or/c number? (-> any/c number?))

A parameter that determines the initial width of the boxes where terms are displayed (measured in characters) for both the stepper and traces.

If its value is a number, then the number is used as the width for every term. If its value is a function, then the function is called with each term and the resulting number is used as the width.

> parameter (dark-pen-color) → (or/c string? (is-a?/c color<%>))
> (dark-pen-color color) → void?
> color : (or/c string? (is-a?/c color<%>))
> parameter (dark-brush-color) → (or/c string? (is-a?/c color<%>))
> (dark-brush-color color) → void?
> color : (or/c string? (is-a?/c color<%>))
> parameter (light-pen-color) → (or/c string? (is-a?/c color<%>))
> (light-pen-color color) → void?
> color : (or/c string? (is-a?/c color<%>))
> parameter (light-brush-color) → (or/c string? (is-a?/c color<%>))
> (light-brush-color color) → void?
> color : (or/c string? (is-a?/c color<%>))
> parameter (dark-text-color) → (or/c string? (is-a?/c color<%>))
> (dark-text-color color) → void?
> color : (or/c string? (is-a?/c color<%>))
> parameter (light-text-color) → (or/c string? (is-a?/c color<%>))
> (light-text-color color) → void?
> color : (or/c string? (is-a?/c color<%>))

These six parameters control the color of the edges in the graph.

The dark colors are used when the mouse is over one of the nodes that is connected to this edge. The light colors are used when it isn’t.

The pen colors control the color of the line. The brush colors control the color used to fill the arrowhead and the text colors control the color used to draw the label on the edge.

> parameter (pretty-print-parameters) → (-> (-> any/c) any/c)
> (pretty-print-parameters f) → void?
> f : (-> (-> any/c) any/c)

A parameter that is used to set other pretty-print parameters.

Specifically, whenever default-pretty-printer prints something it calls f with a thunk that does the actual printing. Thus, f can adjust pretty-print’s parameters to adjust how printing happens.

> procedure (default-pretty-printer v port width text) → void?
> v : any/c
> port : output-port?
> width : exact-nonnegative-integer?
> text : (is-a?/c text%)

This is the default value of pp used by traces and stepper and it uses pretty-print.

This function uses the value of pretty-print-parameters to adjust how it prints.

It sets the pretty-print-columns parameter to width, and it sets pretty-print-size-hook and pretty-print-print-hook to print holes and the symbol 'hole to match the way they are input in a term expression.

#### 2.8`` Typesetting

(require redex/pict)

The redex/pict library provides functions designed to automatically typeset grammars, reduction relations, and metafunction written with plt redex.

Each grammar, reduction relation, and metafunction can be saved in a .ps file (as encapsulated postscript), or can be turned into a pict for viewing in the REPL or using with Slideshow (see Slideshow: Figure and Presentation Tools).

##### 2.8.1`` Picts, PDF, & PostScript

This section documents two classes of operations, one for direct use of creating postscript figures for use in papers and for use in DrRacket to easily adjust the typesetting: render-term, render-language, render-reduction-relation, render-relation, render-judgment-form, render-metafunctions, and render-lw, and one for use in combination with other libraries that operate on picts term->pict, language->pict, reduction-relation->pict, relation->pict, judgment-form->pict, metafunction->pict, and lw->pict. The primary difference between these functions is that the former list sets dc-for-text-size and the latter does not.

> syntax (render-term lang term)
> (render-term lang term file)

Renders the term term. If file is #f or not present, render-term produces a pict; if file is a path, it saves Encapsulated PostScript in the provided filename, unless the filename ends with ".pdf", in which case it saves PDF.

The term argument must be a literal; it is not an evaluated position. For example, this:

> (define-language L)
> (define x (term (+ 1 2)))
> (render-term L x)

will render the term x, not the term (+ 1 2).

See render-language for more details on the construction of the pict.

> syntax (term->pict lang term)

Produces a pict like render-term, but without adjusting dc-for-text-size.

The first argument is expected to be a compiled-language? and the second argument is expected to be a term (without the term wrapper). The formatting in the term argument is used to determine how the resulting pict will look.

This function is primarily designed to be used with Slideshow or with other tools that combine picts together.

> > procedure
> > (render-term/pretty-write |  | lang |  |  |  |
> > |  | term |  |  |  |
> > |  | filename |  |  |  |
> > |  | #:width width) |  | → |  | void?
> lang : compiled-lang?
> term : any/c
> filename : path-string?
> width : #f

Like render-term, except that the term argument is evaluated, and expected to return a term. Then, pretty-write is used to determine where the line breaks go, using the width argument as a maximum width (via pretty-print-columns).

> > procedure
> > (term->pict/pretty-write |  | lang |  |  |  |
> > |  | term |  |  |  |
> > |  | filename |  |  |  |
> > |  | #:width width) |  | → |  | pict?
> lang : compiled-lang?
> term : any/c
> filename : (or/c path-string? #f)
> width : #f

Like term->pict, but with the same change that render-term/pretty-write has from render-term.

> procedure (render-language lang [file #:nts nts]) → (if file void? pict?)
> lang : compiled-lang?
> file : (or/c false/c path-string?) = #f
> | nts |  | : |  | (or/c false/c (listof (or/c string? symbol?)))
> |  |  | = |  | (render-language-nts)

Renders a language. If file is #f, it produces a pict; if file is a path, it saves Encapsulated PostScript in the provided filename, unless the filename ends with ".pdf", in which case it saves PDF. See render-language-nts for information on the nts argument.

This function parameterizes dc-for-text-size to install a relevant dc: a bitmap-dc% or a post-script-dc%, depending on whether file is a path.

See language->pict if you are using Slideshow or are otherwise setting dc-for-text-size.

> procedure (language->pict lang [#:nts nts]) → pict?
> lang : compiled-lang?
> | nts |  | : |  | (or/c false/c (listof (or/c string? symbol?)))
> |  |  | = |  | (render-language-nts)

Produce a pict like render-language, but without adjusting dc-for-text-size.

This function is primarily designed to be used with Slideshow or with other tools that combine picts together.

> > procedure
> > (render-reduction-relation |  | rel |
> > | [ | file |
> > |  | #:style style]) |
> → (if file void? pict?)
> rel : reduction-relation?
> file : (or/c false/c path-string?) = #f
> style : reduction-rule-style/c = (rule-pict-style)

Renders a reduction relation. If file is #f, it produces a pict; if file is a path, it saves Encapsulated PostScript in the provided filename, unless the filename ends with ".pdf", in which case it saves PDF. See rule-pict-style for information on the style argument.

This function parameterizes dc-for-text-size to install a relevant dc: a bitmap-dc% or a post-script-dc%, depending on whether file is a path. See also reduction-relation->pict.

The following forms of arrows can be typeset:

> --> -+> ==> -> => ..> >-> ~~> ~> :-> :–> c-> –>> >– –< >>– –<<

> procedure (reduction-relation->pict r [#:style style]) → pict?
> r : reduction-relation?
> style : reduction-rule-style/c = (rule-pict-style)

Produces a pict like render-reduction-relation, but without setting dc-for-text-size.

This function is primarily designed to be used with Slideshow or with other tools that combine picts together.

> syntax (render-metafunction metafunction-name)
> syntax (render-metafunction metafunction-name filename)
> syntax (render-metafunctions metafunction-name ...)
> syntax (render-metafunctions metafunction-name ... #:file filename)

Like render-reduction-relation but for metafunctions.

Similarly, render-metafunctions accepts multiple metafunctions and renders them together, lining up all of the clauses together.

This function sets dc-for-text-size. See also metafunction->pict and metafunctions->pict.

> syntax (metafunction->pict metafunction-name)

This produces a pict, but without setting dc-for-text-size. It is suitable for use in Slideshow or other libraries that combine picts.

> syntax (metafunctions->pict metafunction-name ...)

Like metafunction->pict, this produces a pict, but without setting dc-for-text-size and is suitable for use in Slideshow or other libraries that combine picts. Like render-metafunctions, it accepts multiple metafunctions and renders them together.

> syntax (render-relation relation-name)
> syntax (render-relation relation-name filename)

Like render-metafunction but for relations.

This function sets dc-for-text-size. See also relation->pict.

> syntax (render-judgment-form judgment-form-name)
> syntax (render-judgment-form judgment-form-name filename)

Like render-metafunction but for judgment forms.

This function sets dc-for-text-size. See also judgment-form->pict.

> syntax (relation->pict relation-name)

This produces a pict, but without setting dc-for-text-size. It is suitable for use in Slideshow or other libraries that combine picts.

> syntax (judgment-form->pict judgment-form-name)

This produces a pict, but without setting dc-for-text-size. It is suitable for use in Slideshow or other libraries that combine picts.

##### 2.8.2`` Customization

> parameter (render-language-nts) → (or/c false/c (listof symbol?))
> (render-language-nts nts) → void?
> nts : (or/c false/c (listof symbol?))

The value of this parameter controls which non-terminals render-language and language->pict render by default. If it is #f (the default), all non-terminals are rendered. If it is a list of symbols, only the listed symbols are rendered.

See also language-nts.

> parameter (extend-language-show-union) → boolean?
> (extend-language-show-union show?) → void?
> show? : boolean?

If this is #t, then a language constructed with extend-language is shown as if the language had been constructed directly with language. If it is #f, then only the last extension to the language is shown (with four-period ellipses, just like in the concrete syntax).

Defaults to #f.

Note that the #t variant can look a little bit strange if .... are used and the original version of the language has multi-line right-hand sides.

> parameter (render-reduction-relation-rules)
> | → |  |
> (or/c false/c
> (listof (or/c symbol?
> string?
> exact-nonnegative-integer?)))
> (render-reduction-relation-rules rules) → void?
> | rules |  | : |  |
> (or/c false/c
> (listof (or/c symbol?
> string?
> exact-nonnegative-integer?)))

This parameter controls which rules in a reduction relation will be rendered. The strings and symbols match the names of the rules and the integers match the position of the rule in the original definition.

> parameter (rule-pict-style) → reduction-rule-style/c
> (rule-pict-style style) → void?
> style : reduction-rule-style/c

This parameter controls the style used by default for the reduction relation. It can be 'horizontal, where the left and right-hand sides of the reduction rule are beside each other or 'vertical, where the left and right-hand sides of the reduction rule are above each other. The 'compact-vertical style moves the reduction arrow to the second line and uses less space between lines. The 'vertical-overlapping-side-conditions variant, the side-conditions don’t contribute to the width of the pict, but are just overlaid on the second line of each rule. The 'horizontal-left-align style is like the 'horizontal style, but the left-hand sides of the rules are aligned on the left, instead of on the right.

> value reduction-rule-style/c : flat-contract?

A contract equivalent to

> (symbols 'vertical
> 'compact-vertical
> 'vertical-overlapping-side-conditions
> 'horizontal)

> parameter (arrow-space) → natural-number/c
> (arrow-space space) → void?
> space : natural-number/c

This parameter controls the amount of extra horizontal space around the reduction relation arrow. Defaults to 0.

> parameter (label-space) → natural-number/c
> (label-space space) → void?
> space : natural-number/c

This parameter controls the amount of extra space before the label on each rule, except in the 'vertical and 'vertical-overlapping-side-conditions modes, where it has no effect. Defaults to 0.

> parameter (metafunction-pict-style)
> | → |  |
> (or/c 'left-right
> 'up-down
> 'left-right/vertical-side-conditions
> 'up-down/vertical-side-conditions
> 'left-right/compact-side-conditions
> 'up-down/compact-side-conditions
> 'left-right/beside-side-conditions)
> (metafunction-pict-style style) → void?
> | style |  | : |  |
> (or/c 'left-right
> 'up-down
> 'left-right/vertical-side-conditions
> 'up-down/vertical-side-conditions
> 'left-right/compact-side-conditions
> 'up-down/compact-side-conditions
> 'left-right/beside-side-conditions)

This parameter controls the style used for typesetting metafunctions. The 'left-right style means that the results of calling the metafunction are displayed to the right of the arguments and the 'up-down style means that the results are displayed below the arguments.

The 'left-right/vertical-side-conditions and 'up-down/vertical-side-conditions variants format side conditions each on a separate line, instead of all on the same line.

The 'left-right/compact-side-conditions and 'up-down/compact-side-conditions variants move side conditions to separate lines to avoid making the rendered form wider than it would be otherwise.

The 'left-right/beside-side-conditions variant is like 'left-right, except it puts the side-conditions on the same line, instead of on a new line below the case.

> parameter (delimit-ellipsis-arguments?) → any/c
> (delimit-ellipsis-arguments? delimit?) → void?
> delimit? : any/c

This parameter controls the typesetting of metafunction definitions and applications. When it is non-#f (the default), commas precede ellipses that represent argument sequences; when it is #f no commas appear in those positions.

> parameter (linebreaks) → (or/c #f (listof boolean?))
> (linebreaks breaks) → void?
> breaks : (or/c #f (listof boolean?))

This parameter controls which cases in the metafunction are rendered on two lines and which are rendered on one.

If its value is a list, the length of the list must match the number of cases and each boolean indicates if that case has a linebreak or not.

This influences the 'left/right styles only.

> parameter (metafunction-cases)
> | → |  |
> (or/c #f (and/c (listof (or/c exact-nonnegative-integer?
> string?))
> pair?))
> (metafunction-cases cases) → void?
> | cases |  | : |  |
> (or/c #f (and/c (listof (or/c exact-nonnegative-integer?
> string?))
> pair?))

Controls which cases in a metafunction are rendered. If it is #f (the default), then all of the cases appear. If it is a list, then only the selected cases appear. The numbers indicate the cases counting from 0 and the strings indicate cases named with clause-name.

This parameter also controls how which clauses in judgment forms are rendered, but only in the case that judgment-form-cases is #f (and in that case, only the numbers are used).

> parameter (judgment-form-cases)
> | → |  |
> (or/c #f
> (and/c (listof (or/c exact-nonnegative-integer?
> string?))
> pair?))
> (judgment-form-cases cases) → void?
> | cases |  | : |  |
> (or/c #f
> (and/c (listof (or/c exact-nonnegative-integer?
> string?))
> pair?))

Controls which clauses in a judgment form are rendered. If it is #f (the default), then all of them are rendered. If it is a list, then only the selected clauses appear (numbers count from 0, and strings correspond to the labels in a judgment form).

> parameter (label-style) → text-style/c
> (label-style style) → void?
> style : text-style/c
> parameter (grammar-style) → text-style/c
> (grammar-style style) → void?
> style : text-style/c
> parameter (paren-style) → text-style/c
> (paren-style style) → void?
> style : text-style/c
> parameter (literal-style) → text-style/c
> (literal-style style) → void?
> style : text-style/c
> parameter (metafunction-style) → text-style/c
> (metafunction-style style) → void?
> style : text-style/c
> parameter (non-terminal-style) → text-style/c
> (non-terminal-style style) → void?
> style : text-style/c
> parameter (non-terminal-subscript-style) → text-style/c
> (non-terminal-subscript-style style) → void?
> style : text-style/c
> parameter (non-terminal-superscript-style) → text-style/c
> (non-terminal-superscript-style style) → void?
> style : text-style/c
> parameter (default-style) → text-style/c
> (default-style style) → void?
> style : text-style/c

These parameters determine the font used for various text in the picts. See text in the texpict collection for documentation explaining text-style/c. One of the more useful things it can be is one of the symbols 'roman, 'swiss, or 'modern, which are a serif, sans-serif, and monospaced font, respectively. (It can also encode style information, too.)

The label-style is used for the reduction rule label names. The literal-style is used for names that aren’t non-terminals that appear in patterns. The metafunction-style is used for the names of metafunctions. The paren-style is used for the parentheses (including “[”, “]”, “{”, and “}”, as well as “(” and “)”), but not for the square brackets used for in-hole decompositions, which use the default-style. The grammar-style is used for the “::=” and “|” in grammars.

The non-terminal-style parameter is used for the names of non-terminals. Two parameters style the text in the (optional) "underscore" component of a non-terminal reference. The first, non-terminal-subscript-style, applies to the segment between the underscore and the first caret (^) to follow it; the second, non-terminal-superscript-style, applies to the segment following that caret. For example, in the non-terminal reference x_y^z, x has style non-terminal-style, y has style non-terminal-subscript-style, and z has style non-terminal-superscript-style.

The default-style is used for parenthesis, the dot in dotted lists, spaces, the "where" and "fresh" in side-conditions, and other places where the other parameters aren’t used.

> parameter (label-font-size) → (and/c (between/c 1 255) integer?)
> (label-font-size size) → void?
> size : (and/c (between/c 1 255) integer?)
> > parameter
> > (metafunction-font-size) |  | → |  |
> > (and/c (between/c 1 255)
> > integer?)
> (metafunction-font-size size) → void?
> | size |  | : |  |
> (and/c (between/c 1 255)
> integer?)
> parameter (default-font-size) → (and/c (between/c 1 255) integer?)
> (default-font-size size) → void?
> size : (and/c (between/c 1 255) integer?)

These parameters control the various font sizes. The default-font-size is used for all of the font sizes except labels and metafunctions.

> parameter (reduction-relation-rule-separation)
> → (parameter/c (and/c integer? positive? exact?))
> (reduction-relation-rule-separation sep) → void?
> sep : (parameter/c (and/c integer? positive? exact?))

Controls the amount of space between clauses in a reduction relation. Defaults to 4.

> parameter (curly-quotes-for-strings) → boolean?
> (curly-quotes-for-strings on?) → void?
> on? : boolean?

Controls if the open and close quotes for strings are turned into “ and ” or are left as merely ".

Defaults to #t.

> parameter (current-text) → (-> string? text-style/c number? pict?)
> (current-text proc) → void?
> proc : (-> string? text-style/c number? pict?)

This parameter’s function is called whenever Redex typesets some part of a grammar, reduction relation, or metafunction. It defaults to slideshow’s text function.

> procedure (arrow->pict arrow) → pict?
> arrow : symbol?

Returns the pict corresponding to arrow.

> procedure (set-arrow-pict! arrow proc) → void?
> arrow : symbol?
> proc : (-> pict?)

This functions sets the pict for a given reduction-relation symbol. When typesetting a reduction relation that uses the symbol, the thunk will be invoked to get a pict to render it. The thunk may be invoked multiple times when rendering a single reduction relation.

> parameter (white-bracket-sizing)
> → (-> string? number? (values number? number? number? number?))
> (white-bracket-sizing proc) → void?
> proc : (-> string? number? (values number? number? number? number?))

This parameter is used when typesetting metafunctions to determine how to create the 〚〛 characters. Rather than using those characters directly (since glyphs tend not to be available in PostScript fonts), they are created by combining two ‘[’ characters or two ‘]’ characters together.

The procedure accepts a string that is either "[" or "]", and returns four numbers. The first two numbers determine the offset (from the left and from the right respectively) for the second square bracket, and the second two two numbers determine the extra space added (to the left and to the right respectively).

The default value of the parameter is:

> (λ (str size)
> (let ([inset-amt (floor/even (max 4 (* size 1/2)))])
> (cond
> [(equal? str "[")
> (values inset-amt
> 0
> 0
> (/ inset-amt 2))]
> [else
> (values 0
> inset-amt
> (/ inset-amt 2)
> 0)])))

where floor/even returns the nearest even number below its argument. This means that for sizes 9, 10, and 11, inset-amt will be 4, and for 12, 13, 14, and 15, inset-amt will be 6.

> parameter (horizontal-bar-spacing)
> → (parameter/c exact-nonnegative-integer?)
> (horizontal-bar-spacing space) → void?
> space : (parameter/c exact-nonnegative-integer?)

Controls the amount of space around the horizontal bar when rendering a relation (that was created by define-relation). Defaults to 4.

> parameter (relation-clauses-combine)
> → (parameter/c (-> (listof pict?) pict?))
> (relation-clauses-combine combine) → void?
> combine : (parameter/c (-> (listof pict?) pict?))

combine is called with the list of picts that are obtained by rendering a relation; it should put them together into a single pict. It defaults to (λ (l) (apply vc-append 20 l))

##### 2.8.3`` Removing the Pink Background

When reduction rules, a metafunction, or a grammar contains unquoted Racket code or side-conditions, they are rendered with a pink background as a guide to help find them and provide an alternative typesetting for them. In general, a good goal for a PLT Redex program that you intend to typeset is to only include such things when they correspond to standard mathematical operations, and the Racket code is an implementation of those operations.

To replace the pink code, use:

> syntax (with-unquote-rewriter proc expression)

Installs proc as the current unquote rewriter and evaluates expression. If that expression computes any picts, the unquote rewriter specified is used to remap them.

The proc must match the contract (-> lw? lw?). Its result should be the rewritten version version of the input.

> > syntax
> > (with-atomic-rewriter name-symbol
> > string-or-thunk-returning-pict
> > expression)

This extends the current set of atomic-rewriters with one new one that rewrites the value of name-symbol to string-or-pict-returning-thunk (applied, in the case of a thunk), during the evaluation of expression.

name-symbol is expected to evaluate to a symbol. The value of string-or-thunk-returning-pict is used whenever the symbol appears in a pattern.

> > syntax
> > (with-compound-rewriter name-symbol
> > proc
> > expression)

This extends the current set of compound-rewriters with one new one that rewrites the value of name-symbol via proc, during the evaluation of expression.

name-symbol is expected to evaluate to a symbol. The value of proc is called with a (listof lw), and is expected to return a new (listof (or/c lw? string? pict?)), rewritten appropriately.

The list passed to the rewriter corresponds to the lw for the sequence that has name-symbol’s value at its head.

The result list is constrained to have at most 2 adjacent non-lws. That list is then transformed by adding lw structs for each of the non-lws in the list (see the text just below the description of lw for a explanation of logical space):

- If there are two adjacent lws, then the logical space between them is filled with whitespace.

- If there is a pair of lws with just a single non-lw between them, a lw will be created (containing the non-lw) that uses all of the available logical space between the lws.

- If there are two adjacent non-lws between two lws, the first non-lw is rendered right after the first lw with a logical space of zero, and the second is rendered right before the last lw also with a logical space of zero, and the logical space between the two lws is absorbed by a new lw that renders using no actual space in the typeset version.

One useful way to take advantage of with-compound-rewriters is to return a list that begins and ends with "" (the empty string). In that situation, any extra logical space that would have been just outside the sequence is replaced with an lw that does not draw anything at all.

> > syntax
> > (with-compound-rewriters ([name-symbol proc] ...)
> > expression)

Shorthand for nested with-compound-rewriter expressions.

> > struct
> > (struct |  | lw | ( | e
> > |  |  |  | line
> > |  |  |  | line-span
> > |  |  |  | column
> > |  |  |  | column-span
> > |  |  |  | unq?
> > |  |  |  | metafunction?)
> > |  | #:constructor-name make-lw
> > |  | #:mutable)
> | e |  | : |  |
> (or/c string?
> symbol?
> pict?
> (listof (or/c (symbols 'spring) lw?)))
> line : exact-positive-integer?
> line-span : exact-positive-integer?
> column : exact-positive-integer?
> column-span : exact-positive-integer?
> unq? : boolean?
> metafunction? : boolean?

The lw data structure corresponds represents a pattern or a Racket expression that is to be typeset. The functions listed above construct lw structs, select fields out of them, and recognize them. The lw binding can be used with copy-struct.

The values of the unq? and metafunction? fields, respectively, indicate whether the lw represents an unquoted expression or a metafunction application. See to-lw for the meanings of the other fields.

> procedure (build-lw e line line-span column column-span) → lw?
> | e |  | : |  |
> (or/c string?
> symbol?
> pict?
> (listof (or/c (symbols 'spring) lw?)))
> line : exact-positive-integer?
> line-span : exact-positive-integer?
> column : exact-positive-integer?
> column-span : exact-positive-integer?

Like make-lw but specialized for constructing lws that do not represent unquoted expressions or metafunction applications.

> syntax (to-lw arg)

This form turns its argument into lw structs that contain all of the spacing information just as it would appear when being used to typeset.

Each sub-expression corresponds to its own lw, and the element indicates what kind of subexpression it is. If the element is a list, then the lw corresponds to a parenthesized sequence, and the list contains a lw for the open paren, one lw for each component of the sequence and then a lw for the close parenthesis. In the case of a dotted list, there will also be a lw in the third-to-last position for the dot.

For example, this expression:

> (a)

becomes this lw (assuming the above expression appears as the first thing in the file):

> (build-lw (list (build-lw "(" 0 0 0 1)
> (build-lw 'a 0 0 1 1)
> (build-lw ")" 0 0 2 1))
> 0 0 0 3)

If there is some whitespace in the sequence, like this one:

> (a b)

then there is no lw that corresponds to that whitespace; instead there is a logical gap between the lws.

> (build-lw (list (build-lw "(" 0 0 0 1)
> (build-lw 'a 0 0 1 1)
> (build-lw 'b 0 0 3 1)
> (build-lw ")" 0 0 4 1))
> 0 0 0 5)

In general, identifiers are represented with symbols and parenthesis are represented with strings and picts can be inserted to render arbitrary pictures.

The line, line-span, column, and column-span correspond to the logical spacing for the redex program, not the actual spacing that will be used when they are rendered. The logical spacing is only used when determining where to place typeset portions of the program. In the absence of any rewriters, these numbers correspond to the line and column numbers in the original program.

The line and column are absolute numbers from the beginning of the file containing the expression. The column number is not necessarily the column of the open parenthesis in a sequence – it is the leftmost column that is occupied by anything in the sequence. The line-span is the number of lines, and the column span is the number of columns on the last line (not the total width).

When there are multiple lines, lines are aligned based on the logical space (ie, the line/column & line-span/column-span) fields of the lws. As an example, if this is the original pattern:

> (all good boys
> deserve fudge)

then the leftmost edges of the words "good" and "deserve" will be lined up underneath each other, but the relative positions of "boys" and "fudge" will be determined by the natural size of the words as they rendered in the appropriate font.

When 'spring appears in the list in the e field of a lw struct, then it absorbs all of the space around it. It is also used by to-lw when constructing the picts for unquoted strings. For example, this expression

> ,x

corresponds to these structs:

> (build-lw (list (build-lw "" 1 0 9 0)
> 'spring
> (build-lw x 1 0 10 1))
> 1 0 9 2)

and the 'spring causes there to be no space between the empty string and the x in the typeset output.

> procedure (to-lw/stx stx) → lw?
> stx : syntax?

This is the runtime variant on to-lw; it accepts a syntax object and returns the corresponding lw structs. It only uses the location information in the syntax object, so metafunctions will not be rendered properly.

> procedure (render-lw language/nts lw) → pict?
> language/nts : (or/c (listof symbol?) compiled-lang?)
> lw : lw?

Produces a pict that corresponds to the lw object argument, using language/nts to determine which of the identifiers in the lw argument are non-terminals.

This function sets dc-for-text-size. See also lw->pict.

> procedure (lw->pict language/ntw lw) → pict?
> language/ntw : (or/c (listof symbol?) compiled-lang?)
> lw : lw?

Produces a pict that corresponds to the lw object argument, using language/nts to determine which of the identifiers in the lw argument are non-terminals.

This does not set the dc-for-text-size parameter. See also render-lw.

> procedure (just-before stuff lw) → lw?
> stuff : (or/c pict? string? symbol?)
> lw : lw?
> procedure (just-after stuff lw) → lw?
> stuff : (or/c pict? string? symbol?)
> lw : lw?

These two helper functions build new lws whose contents are the first argument, and whose line and column are based on the second argument, making the new loc wrapper be either just before or just after that argument. The line-span and column-span of the new lw is always zero.
top ← prev up next →