Scheme 48 Manual | Contents | In Chapter: User's guide
Previous: Disassembler | Next: Library

## Module system

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:

- a set of structures whose bindings are to be visible within the module
- the source code to be evaluated within the module
- a set of exported interfaces

Instantiating a module produces a package and a set of structures, one for each of the exported interfaces.

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 `name ...`)` creates an interface containing `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