1.10 Experimental
The following facilities are experimental.
1.10.1 Contracts for Macro Sub-expressions
This module is deprecated; it reprovides expr/c for backward
compatibility.
1.10.2 Contracts for Syntax Classes
|
| |
| syntax-class-contract | | = | | (syntax-class/c (mandatory-arg ...)) | | | | | | | | | | | | | | | arg | | = | | contract-expr | | | | | | | keyword contract-expr |
|
| |
|
Provides the syntax class (or splicing syntax class)
syntax-class-id with the given contracts imposed on its
formal parameters.
1.10.3 Reflection
A syntax class can be reified into a run-time value, and a reified
syntax class can be used in a pattern via the ~reflect and
~splicing-reflect pattern forms.
Reifies the syntax class named syntax-class-id as a run-time
value. The same form also handles splicing syntax classes. Syntax
classes with the #:no-delimit-cut option cannot be reified.
Returns #t if x is a reified (normal) syntax class
or a reified splicing syntax class, respectively.
Returns the reified syntax class’s attributes.
Partially applies the reified syntax class to the given arguments. If
more arguments are given than the reified syntax class accepts, an
error is raised.
| S-pattern | | = | | .... |
| | | | | | (~reflect var-id (reified-expr arg-expr ...) maybe-attrs) |
| | | | | |
| H-pattern | | = | | .... |
| | | | | | |
| (~reflect var-id (reified-expr arg-expr ...) maybe-attrs) |
| |
| maybe-attrs | | = | | | | | | | | | #:attributes (attr-arity-decl ...) |
|
Like ~var, except that the syntax class position is an
expression evaluating to a reified syntax object, not a syntax class
name, and the attributes bound by the reified syntax class (if any)
must be specified explicitly.
Like ~reflect but for reified splicing syntax classes.
Examples:
|
|
| > (define r-nat> (reify-syntax-class nat>)) |
| > (define r-nat/mult (reify-syntax-class nat/mult)) |
|
| > (partition/r #'(1 2 3 4 5) r-nat> 3) |
#<syntax:5:0 ((4 5) (1 2 3))> |
| > (partition/r #'(1 2 3 4 5) r-nat/mult 2) |
#<syntax:5:0 ((2 4) (1 3 5))> |
|
| > (bad-attrs r-nat>) |
#<syntax 3> |
| > (bad-attrs r-nat/mult) |
reflect-syntax-class: reified syntax-class is missing |
declared attribute `diff' |
1.10.4 Procedural Splicing Syntax Classes
Defines a splicing syntax via a procedural parser.
The parser procedure is given two arguments, the syntax to parse and a
failure procedure. To signal a successful parse, the parser procedure
returns a list of N+1 elements, where N is the
number of attributes declared by the splicing syntax class. The first
element is the size of the prefix consumed. The rest of the list
contains the values of the attributes.
To indicate failure, the parser calls the failure procedure with an
optional message argument.
1.10.5 Ellipsis-head Alternative Sets
Unlike single-term patterns and head patterns, ellipsis-head patterns
cannot be encapsulated by syntax classes, since they describe not only
sets of terms but also repetition constraints.
This module provides ellipsis-head alternative sets,
reusable encapsulations of ellipsis-head patterns.
Defines
name as an ellipsis-head alternative set. Using
name (via
~eh-var) in an ellipsis-head pattern is
equivalent to including each of the alternatives in the pattern via
~alt, except that the attributes bound by the alternatives
are prefixed with the name given to
~eh-var.
Unlike syntax classes, ellipsis-head alternative sets must be defined
before they are referenced.
| EH-pattern | | = | | .... |
| | | | | | (~eh-var name eh-alternative-set-id) |
| (~eh-var name eh-alternative-set-id) |
Includes the alternatives of eh-alternative-set-id, prefixing
their attributes with name.
Examples:
|
|
| > (parse/options #'(m #:a 1 #:b 2 #:b 3)) |
#<syntax:12:0 (1 (2 3))> |
| > (parse/options #'(m #:a 1 #:a 2)) |
m: too many occurrences of #:a option |
at: () |
within: (m #:a 1 #:a 2) |
in: (m #:a 1 #:a 2) |
|
| > (parse/more-options #'(m #:a 1 #:b 2 #:c 3 4 #:c 5 6)) |
#<syntax:15:0 (1 (2) ((3 4) (5 6)))> |
|
|
#<syntax:18:0 (1 (2) ((3 4) (5 6)))> |
1.10.6 Syntax Class Specialization
(define-syntax-class/specialize header syntax-class-use)
|
| |
| header | | = | | id | | | | | | | (id . kw-formals) | | | | | | | | syntax-class-use | | = | | target-stxclass-id | | | | | | | (target-stxclass-id arg ...) |
|
Defines id as a syntax class with the same attributes,
options (eg, #:commit, #:no-delimit-cut), and
patterns as target-stxclass-id but with the given
args supplied.
Examples:
1.10.7 Syntax Templates
(template tmpl)
|
| |
| tmpl | | = | | pattern-variable-id | | | | | | | (head-tmpl . tmpl) | | | | | | | (head-tmpl ellipsis ...+ . tmpl) | | | | | | | (metafunction-id . tmpl) | | | | | | | (?? tmpl tmpl) | | | | | | | #(head-tmpl ...) | | | | | | | #s(prefab-struct-key head-tmpl ...) | | | | | | | #&tmpl | | | | | | | constant-term | | | | | | | | head-templ | | = | | tmpl | | | | | | | (?? head-tmpl) | | | | | | | (?? head-tmpl head-tmpl) | | | | | | | (?@ . tmpl) | | | | | | | | ellipsis | | = | | ... |
|
Constructs a syntax object from a syntax template, like
syntax, but provides additional templating forms for dealing
with optional terms and splicing sequences of terms. Only the
additional forms are described here; see
syntax for
descriptions of pattern variables, etc.
Produces tmpl unless any attribute used in tmpl has
an absent value; in that case, alt-tmpl is used instead.
Examples:
|
#<syntax:22:0 (+ 1 2 3)> |
|
#<syntax:23:0 (max 1 2 3)> |
If ?? is used as a head-template, then its sub-templates may
also be head-templates.
Examples:
|
#<syntax:24:0 (m2 1 #:z 0)> |
|
#<syntax:25:0 (m2 1 #:y 2)> |
Produces head-tmpl unless any attribute used in
head-tmpl has an absent value; in that case, the term is
omitted. Can only occur in head position in a template.
Equivalent to (?? head-tmpl (?@)).
Examples:
|
#<syntax:26:0 (m2 1)> |
|
#<syntax:27:0 (m2 1 2)> |
|
#<syntax:28:0 (m2 1 #:y 2)> |
Similar to unquote-splicing, splices the result of
tmpl (which must produce a syntax list) into the surrounding
template. Can only occur in head position in a template.
Example:
|
#<syntax:29:0 (m2 #:a 1 #:b 2 #:e 5 3 4)> |
The tmpl must produce a proper syntax list, but it does not
need to be expressed as a proper list. For example, to unpack pattern
variables that contain syntax lists, use a “dotted” template:
Examples:
|
#<syntax:30:0 (a b c d)> |
|
#<syntax:31:0 (1 2 3 4 5)> |
Applies the template metafunction named metafunction-id to
the result of the template (including metafunction-id
itself). See define-template-metafunction for examples.
The ?? and ?@ forms and metafunction applications
are disabled in an “escaped template” (see stat-template
under syntax).
Example:
Auxiliary forms used by
template. They may not be used as
expressions.
Defines
metafunction-id as a
template
metafunction. A metafunction application in a
template
expression (but not a
syntax expression) is evaluated by
applying the metafunction to the result of processing the “argument”
part of the template.
Examples:
|
| > (template (join a b c)) |
#<syntax:34:0 abc> |
|
#<syntax:35:0 ((a tmp-a) (b tmp-b) (c tmp-c))> |
Metafunctions are useful for performing transformations in contexts
where macro expansion does not occur, such as binding occurrences. For
example:
|
'(let-values (((posn? make-posn posn-x posn-y) (make-struct-type __))) __) |
If join were defined as a macro, it would not be usable in
the context above; instead, let-values would report an
invalid binding list.