Curry: An Integrated Functional Logic Language

module main where
import m1 hiding (f)
import m2
...
The name f in the main module refers to the entity m2.f since the name f is not imported from
m1 by the hiding declaration. The hiding clause effects only unqualified names, i.e., the entity
m1.f is still accessible in the body of the main module. Therefore, a hiding clause has no effect in
combination with a qualified import. Similarly to export declarations, a datatype t in a hiding
clause hides only the datatype (but not its constructors) whereas the form t(..) hides the complete
datatype including its constructors.
The effect of several import declarations is cumulative, i.e., if an entity is hidden in one import
declaration, it can still be imported by another import declaration. For instance, if module mt
exports a datatype t together with its constructors, then the import declarations
import mt hiding (t(..))
import mt (t)
imports all entities exported by mt but only the name t of the datatype without its constructors,
since the first hiding clause imports everything from mt except the complete datatype t and the
second import specification additionally imports the name of the datatype t.
Imported modules can also be given a new local name in the import declaration. For instance,
the declaration
import m(f) as foo
enables access to the name f (provided that it is not in conflict with another entity with the same
name) and foo.f but not to m.f. This local renaming enables the abbreviation of long module
names and the substitution of different modules without changing the qualifiers inside a module.
Although each name refers to exactly one entity, it is possible that the same entity is referred
by different names. For instance, consider the modules defined by
module m(f) where
f :: Int -> Int
...
module m1(m.f) where
import m
...
module m2(m.f) where
import m
...
together with the main module
module main where
import m1
import m2
...
26