This section gives a brief description of modules and related entities. For detailed information, including a description of the module configuration language, see the module chapter.
A module is an isolated namespace, with visibility of bindings controlled by module descriptions written in a special configuration language. A module may be instantiated as a package, which is an environment in which code can be evaluated. Most modules are instantiated only once and so have a unique package. A structure is a subset of the bindings in a package. Only by being included in a structure can a binding be made visible in other packages. A structure has two parts, the package whose bindings are being exported and the set of names that are to be exported. This set of names is called an interface. A module then has three parts:
The following example uses define-structure
to create a module that
implements simple cells as pairs, instantiates this module, and binds the
resulting structure to cells
.
The syntax (export
creates an interface
containing name ...
)name ...
.
The open
clause lists structures whose bindings are visible
within the module.
The begin
clause contains source code.
(define-structure cells (export make-cell cell-ref cell-set!) (open scheme) (begin (define (make-cell x) (cons 'cell x)) (define cell-ref cdr) (define cell-set! set-cdr!)))
Cells could also have been implemented using the
record facility
and available in structure define-record-type
.
(define-structure cells (export make-cell cell-ref cell-set!) (open scheme define-record-types) (begin (define-record-type cell :cell (make-cell value) cell? (value cell-ref cell-set!))))
With either definition the resulting structure can be used in other
modules by including cells
in an open
clause.
The command interpreter is always operating within a particular package.
Initially this is a package in which only the standard Scheme bindings
are visible.
The bindings of other structures can be made visible by using the
,open
command.
Note that this initial package does not include the configuration language.
Module code needs to be evaluated in the configuration package, which can
be done by using the ,
config command:
> ,config (define-structure cells ...) > ,open cells > (make-cell 4) '(cell . 4) > (define c (make-cell 4)) > (cell-ref c) 4
Previous: Disassembler | Next: Library