Make recursion and RULES interact better

[ghc-hetmet.git] / compiler / basicTypes / BasicTypes.lhs

diff --git a/compiler/basicTypes/BasicTypes.lhs b/compiler/basicTypes/BasicTypes.lhs
index 6b662bd..e6e3a90 100644 (file)
--- a/compiler/basicTypes/BasicTypes.lhs
+++ b/compiler/basicTypes/BasicTypes.lhs
@@ -31,6 +31,8 @@ module BasicTypes(
 
        TopLevelFlag(..), isTopLevel, isNotTopLevel,
 
+       OverlapFlag(..), 
+
        Boxity(..), isBoxed, 
 
        TupCon(..), tupleParens,
@@ -107,24 +109,18 @@ The @IPName@ type is here because it is used in TypeRep (i.e. very
 early in the hierarchy), but also in HsSyn.
 
 \begin{code}
-data IPName name
-  = Dupable   name     -- ?x: you can freely duplicate this implicit parameter
-  | Linear name                -- %x: you must use the splitting function to duplicate it
+newtype IPName name = IPName name      -- ?x
   deriving( Eq, Ord )  -- Ord is used in the IP name cache finite map
                        --      (used in HscTypes.OrigIParamCache)
 
-
 ipNameName :: IPName name -> name
-ipNameName (Dupable n) = n
-ipNameName (Linear  n) = n
+ipNameName (IPName n) = n
 
 mapIPName :: (a->b) -> IPName a -> IPName b
-mapIPName f (Dupable n) = Dupable (f n)
-mapIPName f (Linear  n) = Linear  (f n)
+mapIPName f (IPName n) = IPName (f n)
 
 instance Outputable name => Outputable (IPName name) where
-    ppr (Dupable n) = char '?' <> ppr n -- Ordinary implicit parameters
-    ppr (Linear  n) = char '%' <> ppr n -- Splittable implicit parameters
+    ppr (IPName n) = char '?' <> ppr n -- Ordinary implicit parameters
 \end{code}
 
 
@@ -217,7 +213,7 @@ instance Outputable TopLevelFlag where
 
 %************************************************************************
 %*                                                                     *
-\subsection[Top-level/local]{Top-level/not-top level flag}
+               Top-level/not-top level flag
 %*                                                                     *
 %************************************************************************
 
@@ -235,7 +231,7 @@ isBoxed Unboxed = False
 
 %************************************************************************
 %*                                                                     *
-\subsection[Recursive/Non-Recursive]{Recursive/Non-Recursive flag}
+               Recursive/Non-Recursive flag
 %*                                                                     *
 %************************************************************************
 
@@ -263,6 +259,47 @@ instance Outputable RecFlag where
 
 %************************************************************************
 %*                                                                     *
+               Instance overlap flag
+%*                                                                     *
+%************************************************************************
+
+\begin{code}
+data OverlapFlag
+  = NoOverlap  -- This instance must not overlap another
+
+  | OverlapOk  -- Silently ignore this instance if you find a 
+               -- more specific one that matches the constraint
+               -- you are trying to resolve
+               --
+               -- Example: constraint (Foo [Int])
+               --          instances  (Foo [Int])
+               --                     (Foo [a])        OverlapOk
+               -- Since the second instance has the OverlapOk flag,
+               -- the first instance will be chosen (otherwise 
+               -- its ambiguous which to choose)
+
+  | Incoherent -- Like OverlapOk, but also ignore this instance 
+               -- if it doesn't match the constraint you are
+               -- trying to resolve, but could match if the type variables
+               -- in the constraint were instantiated
+               --
+               -- Example: constraint (Foo [b])
+               --          instances  (Foo [Int])      Incoherent
+               --                     (Foo [a])
+               -- Without the Incoherent flag, we'd complain that
+               -- instantiating 'b' would change which instance 
+               -- was chosen
+  deriving( Eq )
+
+instance Outputable OverlapFlag where
+   ppr NoOverlap  = empty
+   ppr OverlapOk  = ptext SLIT("[overlap ok]")
+   ppr Incoherent = ptext SLIT("[incoherent]")
+
+\end{code}
+
+%************************************************************************
+%*                                                                     *
                Tuples
 %*                                                                     *
 %************************************************************************
@@ -328,12 +365,14 @@ defn of OccInfo here, safely at the bottom
 
 \begin{code}
 data OccInfo 
-  = NoOccInfo
+  = NoOccInfo          -- Many occurrences, or unknown
+
+  | RulesOnly          -- Occurs only in the RHS of one or more rules
 
   | IAmDead            -- Marks unused variables.  Sometimes useful for
                        -- lambda and case-bound variables.
 
-  | OneOcc !InsideLam
+  | OneOcc !InsideLam  -- Occurs exactly once, not inside a rule
           !OneBranch
           !InterestingCxt
 
@@ -385,6 +424,7 @@ isFragileOcc other      = False
 instance Outputable OccInfo where
   -- only used for debugging; never parsed.  KSW 1999-07
   ppr NoOccInfo                                  = empty
+  ppr RulesOnly                                  = ptext SLIT("RulesOnly")
   ppr IAmALoopBreaker                            = ptext SLIT("LoopBreaker")
   ppr IAmDead                                    = ptext SLIT("Dead")
   ppr (OneOcc inside_lam one_branch int_cxt)