Gauche has a simple module system that allows modularized development of large software.
A higher level interface is simple enough from the user’s point
of view. It works like this:
When you want to use the features provided by module
foo, you just need to say
(use foo) in your code.
This form is a macro and interpreted at compile time.
Usually it loads the files that defines
and imports the external APIs into the calling module.
use mechanism is built on top of two independent
lower mechanisms, namespace separation and file loading mechanism.
Those two lower mechanisms can be used separately, although it is much more
convenient when used together.
use mechanism is not transitive; that is,
if a module B uses a module A, and a module C uses the module B,
C doesn’t see the bindings in A. It is because B and A is not in the
Suppose the module A implements a low-level functionality and
the module B implements a high-level abstraction; if C is using
B, what C wants to see is just a high-level abstraction, and
doesn’t concern how B implements such functionality. If C wants
to access low-level stuff, C has to
use A explicitly.
There is another type of relationship, though. You might want to
take an exiting module A, and add some interface to it and provide
the resulting module B as an extension of A. In such a case,
B is-a A, and it’d be natural that the module that uses B can also
see A’s bindings. In Gauche, it is called module inheritance
and realized by
The following sections in this manual describes modules in details.