2.14 Definitions: define, define-syntax, ...

Definitions: define in Guide: Racket introduces definitions.

(CVT (id . kw-formals) . datum)   = (lambda kw-formals . datum)

(CVT (head . kw-formals) . datum) = (lambda kw-formals expr)

if (CVT head . datum) = expr

At the top level, the top-level binding 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.

(define ((f x) [y 20])     (+ x y))

> ((f 10) 30)   40   > ((f 10))   30

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 (x y z) (values 1 2 3))

> z

3

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.

Examples:

> (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)

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.

Examples:

> (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

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 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

reference to undefined identifier: helper

> (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)

Examples:

> (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

2.14.1 require Macros

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 expr is a lambda form.

2.14.2 provide Macros

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.