+ The directory fptools/ghc/compiler/basicTypes/
+ contains modules that define some of the essential types definition for
+ the compiler - such as, identifiers, variables, modules, and unique
+ names. Some of those are discussed in the following. See elsewhere for more
+ detailed information on:
+
Ids
+ An Id (defined in Id.lhs
+ essentially records information about value and data constructor
+ identifiers -- to be precise, in the case of data constructors, two
+ Ids are used to represent the worker and wrapper functions
+ for the data constructor, respectively. The information maintained in
+ the Id abstraction includes among other items strictness,
+ occurrence, specialisation, and unfolding information.
+
+ Due to the way Ids are used for data constructors,
+ all Ids are represented as variables, which contain a
+ varInfo field of abstract type IdInfo.IdInfo.
+ This is where the information about Ids is really stored.
+ The following is a (currently, partial) list of the various items in an
+ IdInfo:
+
+
OccInfo data type is defined in the module BasicTypes.lhs.
+ Apart from the trivial NoOccInfo, it distinguishes
+ between variables that do not occur at all (IAmDead),
+ occur just once (OneOcc), or a loop breakers
+ (IAmALoopBreaker).
+
+ Sets of variables, or more generally names, which are needed throughout
+ the compiler, are provided by the modules VarSet.lhs
+ and NameSet.lhs,
+ respectively. Moreover, frequently maps from variables (or names) to
+ other data is needed. For example, a substitution is represented by a
+ finite map from variable names to expressions. Jobs like this are
+ solved by means of variable and name environments implemented by the
+ modules VarEnv.lhs
+ and NameEnv.lhs.
+
+
VarSet
+ The Module VarSet provides the types VarSet,
+ IdSet, and TyVarSet, which are synonyms in the
+ current implementation, as Var, Id, and
+ TyVar are synonyms. The module provides all the operations
+ that one would expect including the creating of sets from individual
+ variables and lists of variables, union and intersection operations,
+ element checks, deletion, filter, fold, and map functions.
+
+ The implementation is based on UniqSets,
+ which in turn are simply UniqFMs
+ (i.e., finite maps with uniques as keys) that map each unique to the
+ variable that it represents.
+
+
NameSet
+ The Module NameSet provides the same functionality as
+ VarSet only for Names.
+ As for the difference between Names and Vars,
+ a Var is built from a Name plus additional
+ information (mostly importantly type information).
+
+
VarEnv
+ The module VarEnv provides the types VarEnv,
+ IdEnv, and TyVarEnv, which are again
+ synonyms. The provided base functionality is similar to
+ VarSet with the main difference that a type VarEnv
+ T associates a value of type T with each variable in
+ the environment, thus effectively implementing a finite map from
+ variables to values of type T.
+
+ The implementation of VarEnv is also by UniqFM,
+ which entails the slightly surprising implication that it is
+ not possible to retrieve the domain of a variable environment.
+ In other words, there is no function corresponding to
+ VarSet.varSetElems :: VarSet -> [Var] in
+ VarEnv. This is because the UniqFM used to
+ implement VarEnv stores only the unique corresponding to a
+ variable in the environment, but not the entire variable (and there is
+ no mapping from uniques to variables).
+
+ In addition to plain variable environments, the module also contains
+ special substitution environments - the type SubstEnv -
+ that associates variables with a special purpose type
+ SubstResult.
+
+
NameEnv
+ The type NameEnv.NameEnv is like VarEnv only
+ for Names.
+
+