3.14 Definitions: define, define-syntax, ...
Definitions: define in The Racket Guide introduces definitions.
syntax
(define id expr)
(define (head args) body ...+)
head = id | (head args) args = arg ... | arg ... . rest-id arg = arg-id | [arg-id default-expr] | keyword arg-id | keyword [arg-id default-expr]
(CVT (id . kw-formals) . datum) = (lambda kw-formals . datum) (CVT (head . kw-formals) . datum) = (lambda kw-formals expr) if (CVT head . datum) = expr
In an internal-definition context, a define form introduces a local binding; see Internal Definitions. At the top level, the top-level binding for id is created after evaluating expr, if it does not exist already, and the top-level mapping of id (in the namespace linked with the compiled definition) is set to the binding at the same time.
In a context that allows liberal expansion of define, id is bound as syntax if expr is an immediate lambda form with keyword arguments or args include keyword arguments.
(define x 10)
> x 10
(define (f x) (+ x 1))
> (f 10) 11
(define ((f x) [y 20]) (+ x y))
> ((f 10) 30) 40
> ((f 10)) 30
syntax
(define-values (id ...) expr)
In an internal-definition context (see Internal Definitions), a define-values form introduces local bindings. At the top level, the top-level binding for each id is created after evaluating expr, if it does not exist already, and the top-level mapping of each id (in the namespace linked with the compiled definition) is set to the binding at the same time.
> (define-values () (values))
> (define-values (x y z) (values 1 2 3))
> z 3
If a define-values form for a function definition in a module body has a 'compiler-hint:cross-module-inline syntax property with a true value, then the Racket treats the property as a performance hint. See Function-Call Optimizations in The Racket Guide for more information, and see also begin-encourage-inline.
syntax
(define-syntax id expr)
(define-syntax (head args) body ...+)
The second form is a shorthand the same as for define; it expands to a definition of the first form where the expr is a lambda form.
In an internal-definition context (see Internal Definitions), a define-syntax form introduces a local binding.
> (define-syntax foo (syntax-rules () ((_ a ...) (printf "~a\n" (list a ...)))))
> (foo 1 2 3 4) (1 2 3 4)
> (define-syntax (bar syntax-object) (syntax-case syntax-object () ((_ a ...) #'(printf "~a\n" (list a ...)))))
> (bar 1 2 3 4) (1 2 3 4)
syntax
(define-syntaxes (id ...) expr)
When expr produces zero values for a top-level define-syntaxes (i.e., not in a module or internal-definition position), then the ids are effectively declared without binding; see Macro-Introduced Bindings.
In an internal-definition context (see Internal Definitions), a define-syntaxes form introduces local bindings.
> (define-syntaxes (foo1 foo2 foo3) (let ([transformer1 (lambda (syntax-object) (syntax-case syntax-object () [(_) #'1]))] [transformer2 (lambda (syntax-object) (syntax-case syntax-object () [(_) #'2]))] [transformer3 (lambda (syntax-object) (syntax-case syntax-object () [(_) #'3]))]) (values transformer1 transformer2 transformer3)))
> (foo1) 1
> (foo2) 2
> (foo3) 3
syntax
(define-for-syntax id expr)
(define-for-syntax (head args) body ...+)
Within a module, bindings introduced by define-for-syntax must appear before their uses or in the same define-for-syntax form (i.e., the define-for-syntax form must be expanded before the use is expanded). In particular, mutually recursive functions bound by define-for-syntax must be defined by the same define-for-syntax form.
> (define-for-syntax helper 2)
> (define-syntax (make-two syntax-object) (printf "helper is ~a\n" helper) #'2)
> (make-two) helper is 2
2
; ‘helper' is not bound in the runtime phase > helper helper: undefined;
cannot reference undefined identifier
> (define-for-syntax (filter-ids ids) (filter identifier? ids))
> (define-syntax (show-variables syntax-object) (syntax-case syntax-object () [(_ expr ...) (with-syntax ([(only-ids ...) (filter-ids (syntax->list #'(expr ...)))]) #'(list only-ids ...))]))
> (let ([a 1] [b 2] [c 3]) (show-variables a 5 2 b c)) '(1 2 3)
syntax
(define-values-for-syntax (id ...) expr)
> (define-values-for-syntax (foo1 foo2) (values 1 2))
> (define-syntax (bar syntax-object) (printf "foo1 is ~a foo2 is ~a\n" foo1 foo2) #'2)
> (bar) foo1 is 1 foo2 is 2
2
3.14.1 require Macros
| (require racket/require-syntax) | package: base |
syntax
(define-require-syntax id proc-expr)
(define-require-syntax (id args ...) body ...+)
This form expands to define-syntax with a use of make-require-transformer (see require Transformers for more information), and the syntax object passed to and from the macro transformer is adjusted via syntax-local-require-introduce.
The second form is a shorthand the same as for define-syntax; it expands to a definition of the first form where the proc-expr is a lambda form.
procedure
stx : syntax?
3.14.2 provide Macros
| (require racket/provide-syntax) | package: base |
syntax
(define-provide-syntax id proc-expr)
(define-provide-syntax (id args ...) body ...+)
This form expands to define-syntax with a use of make-provide-transformer (see provide Transformers for more information), and the syntax object passed to and from the macro transformer is adjusted via syntax-local-provide-introduce.
The second form is a shorthand the same as for define-syntax; it expands to a definition of the first form where the expr is a lambda form.
procedure
stx : syntax?