The Racket Reference
3 Syntactic Forms
3.14 Definitions: define, define-syntax, ...
On this page:
define
define-values
define-syntax
define-syntaxes
define-for-syntax
define-values-for-syntax
3.14.1require Macros
define-require-syntax
syntax-local-require-introduce
3.14.2provide Macros
define-provide-syntax
syntax-local-provide-introduce
top up

3.14Definitions: define , define-syntax , ...πŸ”— i

+Definitions: define in The Racket Guide introduces definitions.

syntax

( define idexpr)

(define (headargs)body...+)
head = id
| (headargs)
args = arg...
| arg....rest-id
arg = arg-id
| [arg-iddefault-expr]
| keywordarg-id
| keyword[arg-iddefault-expr]
The first form binds id to the result of expr, and the second form binds id to a procedure. In the second case, the generated procedure is (CVT(headargs)body...+ ), using the CVT meta-function defined as follows:

(CVT(id. kw-formals). datum)= (lambda kw-formals. datum)
(CVT(head. kw-formals). datum)= (lambda kw-formalsexpr)
if(CVThead. 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.

Examples:
(define x10)
> x

10

(define (fx)
(+ x1))
> (f10)

11

(define ((fx)[y20])
(+ xy))
> ((f10)30)

40

> ((f10))

30

syntax

(define-values (id...)expr)

Evaluates the expr, and binds the results to the ids, in order, if the number of results matches the number of ids; if expr produces a different number of results, the exn:fail:contract exception is raised.

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.

Examples:
> (define-values ()(values ))
> (define-values (xyz)(values 123))
> 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 idexpr)

(define-syntax (headargs)body...+)
The first form creates a transformer binding (see Transformer Bindings) of id with the value of expr, which is an expression at phase level 1 relative to the surrounding context. (See Identifiers, Binding, and Scopes for information on phase levels.) Evaluation of expr side is parameterize d to set current-namespace as in let-syntax .

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.

Examples:
> (define-syntax foo
(syntax-rules ()
((_ a... )
(printf "~a\n"(list a... )))))
> (foo1234)

(1 2 3 4)

> (define-syntax (barsyntax-object)
(syntax-case syntax-object()
((_ a... )
#'(printf "~a\n"(list a... )))))
> (bar1234)

(1 2 3 4)

syntax

(define-syntaxes (id...)expr)

Like define-syntax , but creates a transformer binding for each id. The expr should produce as many values as ids, and each value is bound to the corresponding id.

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.

Examples:
> (define-syntaxes (foo1foo2foo3)
(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 idexpr)

(define-for-syntax (headargs)body...+)
Like define , except that the binding is at phase level 1 instead of phase level 0 relative to its context. The expression for the binding is also at phase level 1. (See Identifiers, Binding, and Scopes for information on phase levels.) The form is a shorthand for (begin-for-syntax (define idexpr)) or (begin-for-syntax (define (headargs)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.

Examples:
> (define-for-syntax helper2)
> (define-syntax (make-twosyntax-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 an identifier before its definition

in module: top-level

> (define-for-syntax (filter-idsids)
(filter identifier? ids))
> (define-syntax (show-variablessyntax-object)
(syntax-case syntax-object()
[(_ expr... )
(with-syntax ([(only-ids... )
(filter-ids(syntax->list #'(expr... )))])
#'(list only-ids... ))]))
> (let ([a1][b2][c3])
(show-variablesa52bc))

'(1 2 3)

syntax

( define-values-for-syntax (id...)expr)

Like define-for-syntax , but expr must produce as many values as supplied ids, and all of the ids are bound (at phase level 1).

Examples:
> (define-values-for-syntax (foo1foo2)(values 12))
> (define-syntax (barsyntax-object)
(printf "foo1 is ~a foo2 is ~a\n"foo1foo2)
#'2)
> (bar)

foo1 is 1 foo2 is 2

2

3.14.1 require MacrosπŸ”— i

The bindings documented in this section are provided by the racket/require-syntax library, not racket/base or racket.

syntax

( define-require-syntax idproc-expr)

(define-require-syntax (idargs...)body...+)
The first form is like define-syntax , but for a require sub-form. The proc-expr must produce a procedure that accepts and returns a syntax object representing a require sub-form.

This form expands to define-syntax with a use of make-require-transformer (see require Transformers for more information).

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.

For backward compatibility only; equivalent to syntax-local-introduce .

Changed in version 6.90.0.29 of package base: Made equivalent to syntax-local-introduce .

3.14.2 provide MacrosπŸ”— i

The bindings documented in this section are provided by the racket/provide-syntax library, not racket/base or racket.

syntax

( define-provide-syntax idproc-expr)

(define-provide-syntax (idargs...)body...+)
The first form is like define-syntax , but for a provide sub-form. The proc-expr must produce a procedure that accepts and returns a syntax object representing a provide sub-form.

This form expands to define-syntax with a use of make-provide-transformer (see provide Transformers for more information).

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.

For backward compatibility only; equivalent to syntax-local-introduce .

Changed in version 6.90.0.29 of package base: Made equivalent to syntax-local-introduce .

top up

AltStyle γ«γ‚ˆγ£γ¦ε€‰ζ›γ•γ‚ŒγŸγƒšγƒΌγ‚Έ (->γ‚ͺγƒͺγ‚ΈγƒŠγƒ«) /