( Using Guile Modules

Info Catalog ( General Information about Modules ( The Guile module system ( Creating Guile Modules
 31.3.2 Using Guile Modules
 To use a Guile module is to access either its public interface or a
 custom interface ( General Information about Modules).  Both
 types of access are handled by the syntactic form `use-modules', which
 accepts one or more interface specifications and, upon evaluation,
 arranges for those interfaces to be available to the current module.
 This process may include locating and loading code for a given module if
 that code has not yet been loaded, following %load-path ( Build
    An "interface specification" has one of two forms.  The first
 variation is simply to name the module, in which case its public
 interface is the one accessed.  For example:
      (use-modules (ice-9 popen))
    Here, the interface specification is `(ice-9 popen)', and the result
 is that the current module now has access to `open-pipe', `close-pipe',
 `open-input-pipe', and so on ( Included Guile Modules).
    Note in the previous example that if the current module had already
 defined `open-pipe', that definition would be overwritten by the
 definition in `(ice-9 popen)'.  For this reason (and others), there is
 a second variation of interface specification that not only names a
 module to be accessed, but also selects bindings from it and renames
 them to suit the current module's needs.  For example:
      (use-modules ((ice-9 popen)
                    :select ((open-pipe . pipe-open) close-pipe)
                    :renamer (symbol-prefix-proc 'unixy:)))
    Here, the interface specification is more complex than before, and
 the result is that a custom interface with only two bindings is created
 and subsequently accessed by the current module.  The mapping of old to
 new names is as follows:
      (ice-9 popen) sees:             current module sees:
      open-pipe                       unixy:pipe-open
      close-pipe                      unixy:close-pipe
    This example also shows how to use the convenience procedure
  -- Scheme Procedure: symbol-prefix-proc prefix-sym
      Return a procedure that prefixes its arg (a symbol) with
  -- syntax: use-modules spec ...
      Resolve each interface specification SPEC into an interface and
      arrange for these to be accessible by the current module.  The
      return value is unspecified.
      SPEC can be a list of symbols, in which case it names a module
      whose public interface is found and used.
      SPEC can also be of the form:
            (MODULE-NAME [:select SELECTION] [:renamer RENAMER])
      in which case a custom interface is newly created and used.
      MODULE-NAME is a list of symbols, as above; SELECTION is a list of
      selection-specs; and RENAMER is a procedure that takes a symbol
      and returns its new name.  A selection-spec is either a symbol or
      a pair of symbols `(ORIG . SEEN)', where ORIG is the name in the
      used module and SEEN is the name in the using module.  Note that
      SEEN is also passed through RENAMER.
      The `:select' and `:renamer' clauses are optional.  If both are
      omitted, the returned interface has no bindings.  If the `:select'
      clause is omitted, RENAMER operates on the used module's public
      Signal error if module name is not resolvable.
  -- syntax: use-syntax module-name
      Load the module `module-name' and use its system transformer as
      the system transformer for the currently defined module, as well
      as installing it as the current system transformer.
Info Catalog ( General Information about Modules ( The Guile module system ( Creating Guile Modules
automatically generated byinfo2html