X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Ftypes%2FTypeRep.lhs;h=aa1c1fad2f9e58455074a5203ca905c2acc1686c;hb=db375d630cb6e3377e48daaa0388ba5a4f798f7b;hp=5625f8ec32d97842488e15b87935f1f7d3594df2;hpb=c76c69c5b62f1ca4fa52d75b0dfbd37b7eddbb09;p=ghc-hetmet.git

diff --git a/compiler/types/TypeRep.lhs b/compiler/types/TypeRep.lhs
index 5625f8e..aa1c1fa 100644
--- a/compiler/types/TypeRep.lhs
+++ b/compiler/types/TypeRep.lhs
@@ -37,15 +37,12 @@ module TypeRep (
         isTySuperKind, isCoSuperKind,
 	tySuperKindTyCon, coSuperKindTyCon,
         
-        isCoercionKindTyCon,
-
 	pprKind, pprParendKind
     ) where
 
 #include "HsVersions.h"
 
 import {-# SOURCE #-} DataCon( DataCon, dataConName )
-import Monad 	  ( guard )
 -- friends:
 
 import Var	  ( Var, Id, TyVar, tyVarKind )
@@ -53,7 +50,9 @@ import VarSet     ( TyVarSet )
 import Name	  ( Name, NamedThing(..), BuiltInSyntax(..), mkWiredInName )
 import OccName	  ( mkOccNameFS, tcName, parenSymOcc )
 import BasicTypes ( IPName, tupleParens )
-import TyCon	  ( TyCon, mkFunTyCon, tyConArity, tupleTyConBoxity, isTupleTyCon, isRecursiveTyCon, isNewTyCon, mkVoidPrimTyCon, mkSuperKindTyCon, isSuperKindTyCon, mkCoercionTyCon )
+import TyCon	  ( TyCon, mkFunTyCon, tyConArity, tupleTyConBoxity, isTupleTyCon, 
+		    isRecursiveTyCon, isNewTyCon, mkVoidPrimTyCon, 
+		    mkSuperKindTyCon )
 import Class	  ( Class )
 
 -- others
@@ -61,7 +60,7 @@ import PrelNames  ( gHC_PRIM, funTyConKey, tySuperKindTyConKey,
                     coSuperKindTyConKey, liftedTypeKindTyConKey,
                     openTypeKindTyConKey, unliftedTypeKindTyConKey,
                     ubxTupleKindTyConKey, argTypeKindTyConKey, listTyConKey, 
-                    parrTyConKey, hasKey, eqCoercionKindTyConKey )
+                    parrTyConKey, hasKey )
 import Outputable
 \end{code}
 
@@ -192,8 +191,11 @@ data Type
 	TyVar
 	Type	
 
-  | PredTy		-- A high level source type 
-	PredType	-- ...can be expanded to a representation type...
+  | PredTy		-- The type of evidence for a type predictate
+	PredType	-- See Note [PredTy], and Note [Equality predicates]
+	-- NB: A PredTy (EqPred _ _) can appear only as the kind
+	--     of a coercion variable; never as the argument or result
+	--     of a FunTy (unlike ClassP, IParam)
 
   | NoteTy 		-- A type with a note attached
 	TyNote
@@ -208,15 +210,11 @@ type Kind = Type 	-- Invariant: a kind is always
 type SuperKind = Type   -- Invariant: a super kind is always 
                         --   TyConApp SuperKindTyCon ...
 
-type Coercion = Type
-
-type CoercionKind = Kind
-
 data TyNote = FTVNote TyVarSet	-- The free type variables of the noted expression
 \end{code}
 
 -------------------------------------
- 		Source types
+ 		Note [PredTy]
 
 A type of the form
 	PredTy p
@@ -256,6 +254,24 @@ The predicate really does turn into a real extra argument to the
 function.  If the argument has type (PredTy p) then the predicate p is
 represented by evidence (a dictionary, for example, of type (predRepTy p).
 
+Note [Equality predicates]
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+	forall a b. (a :=: S b) => a -> b
+could be represented by
+	ForAllTy a (ForAllTy b (FunTy (PredTy (EqPred a (S b))) ...))
+OR
+	ForAllTy a (ForAllTy b (ForAllTy (c::PredTy (EqPred a (S b))) ...))
+
+The latter is what we do.  (Unlike for class and implicit parameter
+constraints, which do use FunTy.)
+
+Reason:
+	* FunTy is always a *value* function
+	* ForAllTy is discarded at runtime
+
+We often need to make a "wildcard" (c::PredTy..).  We always use the same
+name (wildCoVarName), since it's not mentioned.
+
 
 %************************************************************************
 %*									*
@@ -313,35 +329,29 @@ funTyCon = mkFunTyCon funTyConName (mkArrowKinds [argTypeKind, openTypeKind] lif
 
 
 tySuperKindTyCon     = mkSuperKindTyCon tySuperKindTyConName
-coSuperKindTyCon = mkSuperKindTyCon coSuperKindTyConName
+coSuperKindTyCon     = mkSuperKindTyCon coSuperKindTyConName
 
 liftedTypeKindTyCon   = mkKindTyCon liftedTypeKindTyConName
 openTypeKindTyCon     = mkKindTyCon openTypeKindTyConName
 unliftedTypeKindTyCon = mkKindTyCon unliftedTypeKindTyConName
 ubxTupleKindTyCon     = mkKindTyCon ubxTupleKindTyConName
 argTypeKindTyCon      = mkKindTyCon argTypeKindTyConName
-eqCoercionKindTyCon = 
-  mkCoercionTyCon eqCoercionKindTyConName 2 (\ _ -> coSuperKind)
 
 mkKindTyCon :: Name -> TyCon
-mkKindTyCon name = mkVoidPrimTyCon name tySuperKind 0 [] 
+mkKindTyCon name = mkVoidPrimTyCon name tySuperKind 0
 
 --------------------------
 -- ... and now their names
 
-tySuperKindTyConName     = mkPrimTyConName FSLIT("BOX") tySuperKindTyConKey tySuperKindTyCon
-coSuperKindTyConName = mkPrimTyConName FSLIT("COERCION") coSuperKindTyConKey coSuperKindTyCon
+tySuperKindTyConName      = mkPrimTyConName FSLIT("BOX") tySuperKindTyConKey tySuperKindTyCon
+coSuperKindTyConName      = mkPrimTyConName FSLIT("COERCION") coSuperKindTyConKey coSuperKindTyCon
 liftedTypeKindTyConName   = mkPrimTyConName FSLIT("*") liftedTypeKindTyConKey liftedTypeKindTyCon
 openTypeKindTyConName     = mkPrimTyConName FSLIT("?") openTypeKindTyConKey openTypeKindTyCon
 unliftedTypeKindTyConName = mkPrimTyConName FSLIT("#") unliftedTypeKindTyConKey unliftedTypeKindTyCon
-ubxTupleKindTyConName     = mkPrimTyConName FSLIT("(##)") ubxTupleKindTyConKey ubxTupleKindTyCon
+ubxTupleKindTyConName     = mkPrimTyConName FSLIT("(#)") ubxTupleKindTyConKey ubxTupleKindTyCon
 argTypeKindTyConName      = mkPrimTyConName FSLIT("??") argTypeKindTyConKey argTypeKindTyCon
 funTyConName              = mkPrimTyConName FSLIT("(->)") funTyConKey funTyCon
 
-eqCoercionKindTyConName   = mkWiredInName gHC_PRIM (mkOccNameFS tcName (FSLIT(":=:"))) 
-					eqCoercionKindTyConKey Nothing (ATyCon eqCoercionKindTyCon) 
-					BuiltInSyntax
- 
 mkPrimTyConName occ key tycon = mkWiredInName gHC_PRIM (mkOccNameFS tcName occ) 
 					      key 
 					      Nothing 		-- No parent object
@@ -372,15 +382,15 @@ tySuperKind, coSuperKind :: SuperKind
 tySuperKind = kindTyConType tySuperKindTyCon 
 coSuperKind = kindTyConType coSuperKindTyCon 
 
+isTySuperKind (NoteTy _ ty)    = isTySuperKind ty
 isTySuperKind (TyConApp kc []) = kc `hasKey` tySuperKindTyConKey
 isTySuperKind other            = False
 
+isCoSuperKind :: SuperKind -> Bool
+isCoSuperKind (NoteTy _ ty)    = isCoSuperKind ty
 isCoSuperKind (TyConApp kc []) = kc `hasKey` coSuperKindTyConKey
 isCoSuperKind other            = False
 
-isCoercionKindTyCon kc = kc `hasKey` eqCoercionKindTyConKey
-
-
 -------------------
 -- lastly we need a few functions on Kinds