The previous sections have described a declarative view of the module system. You can also work with it programmatically by accessing and modifying various parts of the Scheme objects that Guile uses to implement the module system.
At any time, there is a current module. This module is the one
where a top-level
define and similar syntax will add new
bindings. You can find other module objects with
These module objects can be used as the second argument to
Return the current module object.
Set the current module to module and return the previous current module.
Call thunk within a
dynamic-wind such that the module that
is current at invocation time is restored when thunk’s dynamic
extent is left (see Dynamic Wind).
More precisely, if thunk escapes non-locally, the current module (at the time of escape) is saved, and the original current module (at the time thunk’s dynamic extent was last entered) is restored. If thunk’s dynamic extent is re-entered, then the current module is saved, and the previously saved inner module is set current again.
Find the module named name and return it. When it has not already
been defined and autoload is true, try to auto-load it. When it
can’t be found that way either, create an empty module if ensure
is true, otherwise return
#f. If version is true, ensure
that the resulting module is compatible with the given version reference
(see R6RS Version References). The name is a list of symbols.
Find the module named name as with
return its interface. The interface of a module is also a module
object, but it contains only the exported bindings.
Return a list of the interfaces used by module.
Add interface to the front of the use-list of module. Both
arguments should be module objects, and interface should very
likely be a module returned by
Revisit the source file that corresponds to module. Raises an error if no source file is associated with the given module.
As mentioned in the previous section, modules contain a mapping between identifiers (as symbols) and storage locations (as variables). Guile defines a number of procedures to allow access to this mapping. If you are programming in C, Accessing Modules from C.
Return the variable bound to name (a symbol) in module, or
#f if name is unbound.
Define a new binding between name (a symbol) and var (a variable) in module.
Look up the value bound to name in module. Like
module-variable, but also does a
variable-ref on the
resulting variable, raising an error if name is unbound.
Locally bind name to value in module. If name
was already locally bound in module, i.e., defined locally and not
by an imported module, the value stored in the existing variable will be
updated. Otherwise, a new variable will be added to the module, via
Update the binding of name in module to value, raising an error if name is not already bound in module.
There are many other reflective procedures available in the default environment. If you find yourself using one of them, please contact the Guile developers so that we can commit to stability for that interface.