[project @ 2002-12-11 17:09:08 by simonpj]

[ghc-hetmet.git] / ghc / compiler / types / TypeRep.lhs

diff --git a/ghc/compiler/types/TypeRep.lhs b/ghc/compiler/types/TypeRep.lhs
index 8e2002c..c8e9f46 100644 (file)
--- a/ghc/compiler/types/TypeRep.lhs
+++ b/ghc/compiler/types/TypeRep.lhs
@@ -6,7 +6,7 @@
 \begin{code}
 module TypeRep (
        Type(..), TyNote(..),           -- Representation visible 
-       SourceType(..), IPName(..),     -- to friends
+       SourceType(..),                 -- to friends
        
        Kind, PredType, ThetaType,              -- Synonyms
        TyVarSubst,
@@ -29,13 +29,14 @@ module TypeRep (
 #include "HsVersions.h"
 
 -- friends:
-import Var     ( TyVar )
-import VarEnv
-import VarSet
-
-import Name    ( Name )
-import TyCon   ( TyCon, KindCon, mkFunTyCon, mkKindCon, mkSuperKindCon )
-import Class   ( Class )
+import Var       ( TyVar )
+import VarEnv     ( TyVarEnv )
+import VarSet     ( TyVarSet )
+import Name      ( Name )
+import BasicTypes ( IPName )
+import TyCon     ( TyCon, KindCon, mkFunTyCon, mkKindCon, mkSuperKindCon )
+import Class     ( Class )
+import Binary
 
 -- others
 import PrelNames       ( superKindName, superBoxityName, liftedConName, 
@@ -126,6 +127,12 @@ The TyCon still says "I'm a newtype", but we do not represent the
 newtype application as a SourceType; instead as a TyConApp.
 
 
+NOTE: currently [March 02] we regard a newtype as 'recursive' if it's in a
+mutually recursive group.  That's a bit conservative: only if there's a loop
+consisting only of newtypes do we need consider it as recursive.  But it's
+not so easy to discover that, and the situation isn't that common.
+
+
 %************************************************************************
 %*                                                                     *
 \subsection{The data type}
@@ -162,10 +169,6 @@ data Type
   | SourceTy           -- A high level source type 
        SourceType      -- ...can be expanded to a representation type...
 
-  | UsageTy            -- A usage-annotated type
-       Type            --   - Annotation of kind $ (i.e., usage annotation)
-       Type            --   - Annotated type
-
   | NoteTy             -- A type with a note attached
        TyNote
        Type            -- The expanded version
@@ -176,12 +179,8 @@ data TyNote
   | SynNote Type       -- Used for type synonyms
                        -- The Type is always a TyConApp, and is the un-expanded form.
                        -- The type to which the note is attached is the expanded form.
-\end{code}
 
-INVARIANT: UsageTys are optional, but may *only* appear immediately
-under a FunTy (either argument), or at top-level of a Type permitted
-to be annotated (such as the type of an Id).  NoteTys are transparent
-for the purposes of this rule.
+\end{code}
 
 -------------------------------------
                Source types
@@ -213,13 +212,6 @@ data SourceType
   | NType TyCon [Type]         -- A *saturated*, *non-recursive* newtype application
                                -- [See notes at top about newtypes]
 
-data IPName name
-  = Dupable   name     -- ?x: you can freely duplicate this implicit parameter
-  | MustSplit name     -- %x: you must use the splitting function to duplicate it
-  deriving( Eq, Ord )  -- Ord is used in the IP name cache finite map
-                       --      (used in HscTypes.OrigIParamCache)
-       -- I sometimes thisnk this type should be in BasicTypes
-               
 type PredType  = SourceType    -- A subtype for predicates
 type ThetaType = [PredType]
 \end{code}
@@ -302,9 +294,11 @@ Define boxities: @*@ and @#@
 
 \begin{code}
 liftedBoxity, unliftedBoxity :: Kind           -- :: BX
-liftedBoxity  = TyConApp (mkKindCon liftedConName superBoxity) []
+liftedBoxity   = TyConApp liftedBoxityCon   []
+unliftedBoxity = TyConApp unliftedBoxityCon []
 
-unliftedBoxity  = TyConApp (mkKindCon unliftedConName superBoxity) []
+liftedBoxityCon   = mkKindCon liftedConName superBoxity
+unliftedBoxityCon = mkKindCon unliftedConName superBoxity
 \end{code}
 
 ------------------------------------------
@@ -337,6 +331,29 @@ mkArrowKinds :: [Kind] -> Kind -> Kind
 mkArrowKinds arg_kinds result_kind = foldr mkArrowKind result_kind arg_kinds
 \end{code}
 
+-----------------------------------------------------------------------------
+Binary kinds for interface files
+
+\begin{code}
+instance Binary Kind where
+  put_ bh k@(TyConApp tc [])
+       | tc == openKindCon  = putByte bh 0
+       | tc == usageKindCon = putByte bh 1
+  put_ bh k@(TyConApp tc [TyConApp bc _])
+       | tc == typeCon && bc == liftedBoxityCon   = putByte bh 2
+       | tc == typeCon && bc == unliftedBoxityCon = putByte bh 3
+  put_ bh (FunTy f a) = do putByte bh 4;       put_ bh f; put_ bh a
+  put_ bh _ = error "Binary.put(Kind): strange-looking Kind"
+
+  get bh = do 
+       b <- getByte bh
+       case b of 
+         0 -> return openTypeKind
+         1 -> return usageTypeKind
+         2 -> return liftedTypeKind
+         3 -> return unliftedTypeKind
+         _ -> do f <- get bh; a <- get bh; return (FunTy f a)
+\end{code}
 
 %************************************************************************
 %*                                                                     *
@@ -348,6 +365,13 @@ We define a few wired-in type constructors here to avoid module knots
 
 \begin{code}
 funTyCon = mkFunTyCon funTyConName (mkArrowKinds [liftedTypeKind, liftedTypeKind] liftedTypeKind)
+       -- You might think that (->) should have type (? -> ? -> *), and you'd be right
+       -- But if we do that we get kind errors when saying
+       --      instance Control.Arrow (->)
+       -- becuase the expected kind is (*->*->*).  The trouble is that the
+       -- expected/actual stuff in the unifier does not go contra-variant, whereas
+       -- the kind sub-typing does.  Sigh.  It really only matters if you use (->) in
+       -- a prefix way, thus:  (->) Int# Int#.  And this is unusual.
 \end{code}
 
 ------------------------------------------