%
-% (c) The GRASP/AQUA Project, Glasgow University, 1997
+% (c) The GRASP/AQUA Project, Glasgow University, 1997-1998
%
\section[BasicTypes]{Miscellanous types}
\end{itemize}
\begin{code}
-#include "HsVersions.h"
-
module BasicTypes(
- SYN_IE(Version), SYN_IE(Arity),
- SYN_IE(Module), moduleString, pprModule,
+ Version, bumpVersion, initialVersion, bogusVersion,
+
+ Arity,
+
+ Unused, unused,
+
Fixity(..), FixityDirection(..),
- NewOrData(..), IfaceFlavour(..)
+ defaultFixity, maxPrecedence, negateFixity, negatePrecedence,
+
+ NewOrData(..),
+
+ RecFlag(..), isRec, isNonRec,
+
+ TopLevelFlag(..), isTopLevel, isNotTopLevel,
+
+ Boxity(..), isBoxed, tupleParens,
+
+ OccInfo(..), seqOccInfo, isFragileOcc, isDeadOcc, isLoopBreaker,
+
+ InsideLam, insideLam, notInsideLam,
+ OneBranch, oneBranch, notOneBranch,
+
+ EP(..)
) where
-IMP_Ubiq()
+#include "HsVersions.h"
-import Pretty
import Outputable
+\end{code}
+
+%************************************************************************
+%* *
+\subsection[Unused]{Unused}
+%* *
+%************************************************************************
+Used as a placeholder in types.
+
+\begin{code}
+type Unused = ()
+
+unused :: Unused
+unused = error "Unused is used!"
\end{code}
+
%************************************************************************
%* *
\subsection[Arity]{Arity}
\begin{code}
type Version = Int
+
+bogusVersion :: Version -- Shouldn't look at these
+bogusVersion = error "bogusVersion"
+
+bumpVersion :: Bool -> Version -> Version
+-- Bump if the predicate (typically equality between old and new) is false
+bumpVersion False v = v+1
+bumpVersion True v = v
+
+initialVersion :: Version
+initialVersion = 1
\end{code}
%************************************************************************
%* *
-\subsection[Module]{The name of a module}
+\subsection[Fixity]{Fixity info}
%* *
%************************************************************************
\begin{code}
-type Module = FAST_STRING
+data Fixity = Fixity Int FixityDirection
+data FixityDirection = InfixL | InfixR | InfixN
+ deriving(Eq)
+
+instance Outputable Fixity where
+ ppr (Fixity prec dir) = hcat [ppr dir, space, int prec]
+
+instance Outputable FixityDirection where
+ ppr InfixL = ptext SLIT("infixl")
+ ppr InfixR = ptext SLIT("infixr")
+ ppr InfixN = ptext SLIT("infix")
+
+instance Eq Fixity where -- Used to determine if two fixities conflict
+ (Fixity p1 dir1) == (Fixity p2 dir2) = p1==p2 && dir1 == dir2
+
+maxPrecedence = (9::Int)
+defaultFixity = Fixity maxPrecedence InfixL
-moduleString :: Module -> String
-moduleString mod = _UNPK_ mod
+negateFixity :: Fixity
+negateFixity = Fixity negatePrecedence InfixL -- Precedence of unary negate is wired in as infixl 6!
-pprModule :: PprStyle -> Module -> Doc
-pprModule sty m = ptext m
+negatePrecedence :: Int
+negatePrecedence = 6
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection[NewType/DataType]{NewType/DataType flag}
+%* *
+%************************************************************************
+
+\begin{code}
+data NewOrData
+ = NewType -- "newtype Blah ..."
+ | DataType -- "data Blah ..."
+ deriving( Eq ) -- Needed because Demand derives Eq
\end{code}
%************************************************************************
%* *
-\subsection[IfaceFlavour]{IfaceFlavour}
+\subsection[Top-level/local]{Top-level/not-top level flag}
%* *
%************************************************************************
-The IfaceFlavour type is used mainly in an imported Name's Provenance
-to say whether the name comes from a regular .hi file, or whether it comes
-from a hand-written .hi-boot file. This is important, because it has to be
-propagated. Suppose
+\begin{code}
+data TopLevelFlag
+ = TopLevel
+ | NotTopLevel
+
+isTopLevel, isNotTopLevel :: TopLevelFlag -> Bool
- C.hs imports B
- B.hs imports A
- A.hs imports C {-# SOURCE -#} ( f )
+isNotTopLevel NotTopLevel = True
+isNotTopLevel TopLevel = False
-Then in A.hi we may mention C.f, in an inlining. When compiling B we *must not*
-read C.f's details from C.hi, even if the latter happens to exist from an earlier
-compilation run. So we use the name "C!f" in A.hi, and when looking for an interface
-file with details of C!f we look in C.hi-boot. The "!" stuff is recorded in the
-IfaceFlavour in the Name of C.f in A.
+isTopLevel TopLevel = True
+isTopLevel NotTopLevel = False
+\end{code}
-Not particularly beautiful, but it works.
+%************************************************************************
+%* *
+\subsection[Top-level/local]{Top-level/not-top level flag}
+%* *
+%************************************************************************
\begin{code}
-data IfaceFlavour = HiFile -- The interface was read from a standard interface file
- | HiBootFile -- ... or from a handwritten "hi-boot" interface file
+data Boxity
+ = Boxed
+ | Unboxed
+ deriving( Eq )
-instance Text IfaceFlavour where -- Just used in debug prints of lex tokens
- showsPrec n HiFile s = s
- showsPrec n HiBootFile s = "!" ++ s
+isBoxed :: Boxity -> Bool
+isBoxed Boxed = True
+isBoxed Unboxed = False
+
+tupleParens :: Boxity -> SDoc -> SDoc
+tupleParens Boxed p = parens p
+tupleParens Unboxed p = ptext SLIT("(#") <+> p <+> ptext SLIT("#)")
\end{code}
%************************************************************************
%* *
-\subsection[Fixity]{Fixity info}
+\subsection[Recursive/Non-Recursive]{Recursive/Non-Recursive flag}
%* *
%************************************************************************
-\begin{code}
-data Fixity = Fixity Int FixityDirection
-data FixityDirection = InfixL | InfixR | InfixN
- deriving(Eq)
+\begin{code}
+data RecFlag = Recursive
+ | NonRecursive
-instance Outputable Fixity where
- ppr sty (Fixity prec dir) = hcat [ppr sty dir, space, int prec]
+isRec :: RecFlag -> Bool
+isRec Recursive = True
+isRec NonRecursive = False
-instance Outputable FixityDirection where
- ppr sty InfixL = ptext SLIT("infixl")
- ppr sty InfixR = ptext SLIT("infixr")
- ppr sty InfixN = ptext SLIT("infix")
+isNonRec :: RecFlag -> Bool
+isNonRec Recursive = False
+isNonRec NonRecursive = True
+\end{code}
-instance Eq Fixity where -- Used to determine if two fixities conflict
- (Fixity p1 dir1) == (Fixity p2 dir2) = p1==p2 && dir1 == dir2
+%************************************************************************
+%* *
+\subsection[Generic]{Generic flag}
+%* *
+%************************************************************************
+
+This is the "Embedding-Projection pair" datatype, it contains
+two pieces of code (normally either RenamedHsExpr's or Id's)
+If we have a such a pair (EP from to), the idea is that 'from' and 'to'
+represents functions of type
+
+ from :: T -> Tring
+ to :: Tring -> T
+
+And we should have
+
+ to (from x) = x
+
+T and Tring are arbitrary, but typically T is the 'main' type while
+Tring is the 'representation' type. (This just helps us remember
+whether to use 'from' or 'to'.
+
+\begin{code}
+data EP a = EP { fromEP :: a, -- :: T -> Tring
+ toEP :: a } -- :: Tring -> T
\end{code}
+Embedding-projection pairs are used in several places:
+
+First of all, each type constructor has an EP associated with it, the
+code in EP converts (datatype T) from T to Tring and back again.
+
+Secondly, when we are filling in Generic methods (in the typechecker,
+tcMethodBinds), we are constructing bimaps by induction on the structure
+of the type of the method signature.
+
%************************************************************************
%* *
-\subsection[NewType/DataType]{NewType/DataType flag}
+\subsection{Occurrence information}
%* *
%************************************************************************
+This data type is used exclusively by the simplifier, but it appears in a
+SubstResult, which is currently defined in VarEnv, which is pretty near
+the base of the module hierarchy. So it seemed simpler to put the
+defn of OccInfo here, safely at the bottom
+
\begin{code}
-data NewOrData
- = NewType -- "newtype Blah ..."
- | DataType -- "data Blah ..."
- deriving( Eq )
+data OccInfo
+ = NoOccInfo
+
+ | IAmDead -- Marks unused variables. Sometimes useful for
+ -- lambda and case-bound variables.
+
+ | OneOcc InsideLam
+
+ OneBranch
+
+ | IAmALoopBreaker -- Used by the occurrence analyser to mark loop-breakers
+ -- in a group of recursive definitions
+
+seqOccInfo :: OccInfo -> ()
+seqOccInfo (OneOcc in_lam once) = in_lam `seq` once `seq` ()
+seqOccInfo occ = ()
+
+type InsideLam = Bool -- True <=> Occurs inside a non-linear lambda
+ -- Substituting a redex for this occurrence is
+ -- dangerous because it might duplicate work.
+insideLam = True
+notInsideLam = False
+
+type OneBranch = Bool -- True <=> Occurs in only one case branch
+ -- so no code-duplication issue to worry about
+oneBranch = True
+notOneBranch = False
+
+isLoopBreaker :: OccInfo -> Bool
+isLoopBreaker IAmALoopBreaker = True
+isLoopBreaker other = False
+
+isDeadOcc :: OccInfo -> Bool
+isDeadOcc IAmDead = True
+isDeadOcc other = False
+
+isFragileOcc :: OccInfo -> Bool
+isFragileOcc (OneOcc _ _) = True
+isFragileOcc other = False
+\end{code}
+
+\begin{code}
+instance Outputable OccInfo where
+ -- only used for debugging; never parsed. KSW 1999-07
+ ppr NoOccInfo = empty
+ ppr IAmALoopBreaker = ptext SLIT("_Kx")
+ ppr IAmDead = ptext SLIT("_Kd")
+ ppr (OneOcc inside_lam one_branch) | inside_lam = ptext SLIT("_Kl")
+ | one_branch = ptext SLIT("_Ks")
+ | otherwise = ptext SLIT("_Ks*")
+
+instance Show OccInfo where
+ showsPrec p occ = showsPrecSDoc p (ppr occ)
\end{code}
+