Reference: PLT Scheme

1`` | Language Model
2`` | Syntactic Forms
3`` | Datatypes
4`` | Structures
5`` | Classes and Objects
6`` | Units
7`` | Contracts
8`` | Pattern Matching
9`` | Control Flow
10`` | Concurrency
11`` | Macros
12`` | Input and Output
13`` | Reflection and Security
14`` | Operating System
15`` | Memory Management
16`` | Running PLT Scheme
| Bibliography
| Index

On this page:

define
define-values
define-syntax
define-syntaxes
define-for-syntax
define-values-for-syntax
2.14.1`` require Macros
define-require-syntax
2.14.2`` provide Macros
define-provide-syntax

Version: 4.0.2
contents index
← prev up next →

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

contents index
← prev up next →