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

Definitions: define in Guide: PLT Scheme introduces definitions.

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

The first form binds id to the result of expr, and the second form binds id to a procedure. In the second case, the generation procedure is (CVT (head args) 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-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.

Examples:

(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

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

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

(define-syntax id expr)

(define-syntax (head args) 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 and Binding for information on phase levels.)

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.

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

(define-for-syntax id expr)

(define-for-syntax (head args) 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 and Binding for information on phase levels.)

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

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

2.14.1 require Macros

(require scheme/require-syntax)

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

(define-require-syntax id proc-expr)

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.

2.14.2 provide Macros

(require scheme/provide-syntax)

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

(define-provide-syntax id proc-expr)

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.