Curry: An Integrated Functional Logic Language

to the module head. For instance, a module with the head
module stack(stackType, push, pop, newStack) where ...
exports the entities stackType, push, pop, and newStack. An export list can contain the following
entries:
1. Names of datatypes: This exports only the datatype, whose name must be accessible in this
module, but not the constructors of the datatype. The export of a datatype without its
constructors allows the definition of abstract datatypes.
2. Datatypes with all constructors: If the export list contains the entry t(..), then t must be
a datatype whose name is in the module. In this case, the datatype t and all constructors of
this datatype, which must be also accessible in this module, are exported.
3. Names of functions: This exports the corresponding functions whose names must be accessible
in this module. The types occurring in the argument and result type of this function are
implicitly exported, otherwise the function may not be applicable outside this module.
4. Modules: The set of all accessible entities imported from a module m into the current module
(see below) can be exported by a single entry “module m” in the export list. For instance, if
the head of the module stack is defined as above, the module head
module queue(module stack, enqueue, dequeue) where ...
specifies that the module queue exports the entities stackType, push, pop, newStack,
enqueue, and dequeue.
The unqualified names of the exported entities of a module must be pairwise different to avoid
name clashes in the use of these entities. For instance, the module
module m(f,ma.g) where
import ma
f x = ma.g x
exports the names m.f and m.g, i.e., a qualified entity consists always of the name of the exported
module followed by a dot and the unqualified name of the entity (without spaces between the dot
and the names). If module ma also exports the entity f, then the export declaration
module m(f,ma.f) where
import ma
f x = ma.f x
is not allowed since the exported name m.f cannot be uniquely resolved.
All entities defined by top-level declarations in a module are always accessible in this module,
i.e., there is no need to qualify the names of top-level declarations. Additionally, the entities
exported by another module can be also made accessible in the module by an import declaration.
An import declaration consists of the name of the imported module and (optionally) a list of entities
imported from that module. If the list of imported entities is omitted, all entities exported by that
module are imported. For instance, the import declaration
24