[project @ 1996-01-08 20:28:12 by partain]
[ghc.git] / ghc / docs / NOTES.rename
1
2
3
4 Questions concerning the meaning of hiding in certain contexts:
5
6 1) Suppose we have the interface
7    interface A where
8    data T = B | C
9
10    and the module
11    module H where
12    import A hiding T
13
14    Should this be an error (because T isn't an abstract type in the module)
15    or does it just mean the same thing as would 
16    import A hiding (T (B,C))
17    or
18    import A hiding (T (..))
19    (in other words, hide all of T)
20    Will require the user to be precise and flag it as an error - otherwise
21    the user may not know that the type is not abstract, thinking that it is.
22
23 2) Clearly, we can't allow (assuming the interface above)
24    module H where
25    import A hiding (T (B))
26
27    since that means that a data type with a subset of the constructors is
28    exported - similarly for classes
29
30 3) Suppose an interface exports an abstract type H. Can H be referred
31    to as H (..), or is that an error? Let's require precision and call it
32    an error.
33
34 --------------- new design for renamer -------------------
35
36 Changes to abstract syntax
37
38 1) ClsSigs becomes Sigs
39
40 2) Instances need new syntax (bool) distinguishing between those which
41 come from an interface and those which come from a module. 
42
43 The renamer is factored into four passes, as follows:
44
45 1) FLATTEN INTERFACES -
46    insert original names into interfaces. All of the decls imported
47    from the interfaces are collected and returned, in an otherwise
48    unchanged module. No interfaces exist after this pass.
49
50 2) Do consistency checks (equality). Return the module including the surviving declarations.
51
52 3) build the global name function, which will maintain two separate
53    namespaces.
54
55 4) assign names to the entire module, and do dependency analysis.
56
57 As the prelude environments will yield names, the first pass will replace
58 QuickStrings with constructors of the ProtoName type, defined as
59
60 data ProtoName = Unknown QuickString
61                         -- note that this is the name local to the module
62                | Imported QuickString QuickString QuickString
63                | Prelude Name
64
65 The parser will initially make all QuickStrings Unknown.
66
67 Modules must now include signatures for value decls at top level.
68
69 The entire set of passes have the following types:
70
71 type PrelNameFuns = (GlobalNameFun, GlobalNameFun)
72
73 type GlobalNameFun = ProtoName -> Maybe Name
74
75 renameModule :: PrelNameFuns -> ProtoNameModule -> RenameMonad RenamedModule
76
77 renameModule1 :: PrelNameFuns -> ProtoNameModule -> RenameMonad ProtoNameModule
78
79 processModImports1 :: PrelNameFuns -> ProtoNameImportDecls 
80                         -> RenameMonad (ProtoNameFixityDecls, ProtoNameTyDecls, 
81                                         ProtoNameClassDecls, ProtoNameInstDecls, 
82                                         ProtoNameSigDecls)
83
84 renameModule2 :: ProtoNameModule -> RenameMonad ProtoNameModule
85
86 renameModule3 :: PrelNameFuns -> ProtoNameModule -> GlobalNameFun
87
88 renameModule4 ::  GlobalNameFun -> ProtoNameModule -> RenameMonad RenamedModule
89
90 renameModule :: PrelNameFuns -> ProtoNameModule -> RenameMonad RenamedModule
91 renameModule pnf mod 
92  = (renameModule1 pnf mod)      `thenRenameM` (\ mod_with_orig_interfaces ->
93    (renameModule2 mod_with_orig_interfaces) 
94                          `thenRenameM` (\ mod_minus_interfaces ->
95    (renameModule3 pnf mod_minus_interfaces)
96                          `thenRenameM` (\ global_name_fun ->
97    (renameModule4 mod_minus_interfaces global_name_fun))))
98
99 Namespace confusion: According to the report (1.1), `An identifier must
100 not be used as the name of a type constructor and a class in the same 
101 scope.' This is apparently the only constraint on the namespace, other
102 than those implied by the conventions for identifiers. So, what are the
103 namespaces? 
104
105 1) variables and class operations, constructors
106
107 2) type constructors and classes (because of the statement above)
108
109