X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FInst.lhs;h=1c8cc423b2c475c87b207d8990a4592cf8b583d6;hp=cff48e382f1761fd3d42f98cf892ff2f67a047ea;hb=e6d057711f4d6d6ff6342c39fa2b9e44d25447f1;hpb=f80b81f8b56ebd0fa0f7f82494a5090e9ab64256

diff --git a/compiler/typecheck/Inst.lhs b/compiler/typecheck/Inst.lhs
index cff48e3..1c8cc42 100644
--- a/compiler/typecheck/Inst.lhs
+++ b/compiler/typecheck/Inst.lhs
@@ -43,7 +43,7 @@ import {-# SOURCE #-}	TcExpr( tcPolyExpr )
 import {-# SOURCE #-}	TcUnify( unifyType )
 
 import HsSyn	( HsLit(..), HsOverLit(..), HsExpr(..), LHsExpr, mkHsApp,
-		  ExprCoFn(..), (<.>), mkCoTyApps, idCoercion,
+		  HsWrapper(..), (<.>), mkWpTyApps, idHsWrapper,
 		  nlHsLit, nlHsVar )
 import TcHsSyn	( zonkId )
 import TcRnMonad
@@ -230,18 +230,18 @@ newDictBndr inst_loc pred
 	; return (Dict name pred inst_loc) }
 
 ----------------
-instCall :: InstOrigin -> [TcType] -> TcThetaType -> TcM ExprCoFn
+instCall :: InstOrigin -> [TcType] -> TcThetaType -> TcM HsWrapper
 -- Instantiate the constraints of a call
 --	(instCall o tys theta)
 -- (a) Makes fresh dictionaries as necessary for the constraints (theta)
 -- (b) Throws these dictionaries into the LIE
--- (c) Eeturns an ExprCoFn ([.] tys dicts)
+-- (c) Eeturns an HsWrapper ([.] tys dicts)
 
 instCall orig tys theta 
   = do	{ loc <- getInstLoc orig
 	; (dicts, dict_app) <- instCallDicts loc theta
 	; extendLIEs dicts
-	; return (dict_app <.> mkCoTyApps tys) }
+	; return (dict_app <.> mkWpTyApps tys) }
 
 ----------------
 instStupidTheta :: InstOrigin -> TcThetaType -> TcM ()
@@ -253,17 +253,17 @@ instStupidTheta orig theta
 	; extendLIEs dicts }
 
 ----------------
-instCallDicts :: InstLoc -> TcThetaType -> TcM ([Inst], ExprCoFn)
+instCallDicts :: InstLoc -> TcThetaType -> TcM ([Inst], HsWrapper)
 -- This is the key place where equality predicates 
 -- are unleashed into the world
-instCallDicts loc [] = return ([], idCoercion)
+instCallDicts loc [] = return ([], idHsWrapper)
 
 instCallDicts loc (EqPred ty1 ty2 : preds)
   = do  { unifyType ty1 ty2	-- For now, we insist that they unify right away 
 				-- Later on, when we do associated types, 
 				-- unifyType :: Type -> Type -> TcM ([Inst], Coercion)
 	; (dicts, co_fn) <- instCallDicts loc preds
-	; return (dicts, co_fn <.> CoTyApp ty1) }
+	; return (dicts, co_fn <.> WpTyApp ty1) }
 	-- We use type application to apply the function to the 
 	-- coercion; here ty1 *is* the appropriate identity coercion
 
@@ -272,7 +272,7 @@ instCallDicts loc (pred : preds)
 	; let name = mkPredName uniq (instLocSrcLoc loc) pred 
 	      dict = Dict name pred loc
 	; (dicts, co_fn) <- instCallDicts loc preds
-	; return (dict:dicts, co_fn <.> CoApp (instToId dict)) }
+	; return (dict:dicts, co_fn <.> WpApp (instToId dict)) }
 
 -------------
 cloneDict :: Inst -> TcM Inst	-- Only used for linear implicit params
@@ -620,8 +620,8 @@ lookupInst :: Inst -> TcM LookupInstResult
 
 lookupInst inst@(Method _ id tys theta loc)
   = do	{ (dicts, dict_app) <- instCallDicts loc theta
-	; let co_fn = dict_app <.> mkCoTyApps tys
-	; return (GenInst dicts (L span $ HsCoerce co_fn (HsVar id))) }
+	; let co_fn = dict_app <.> mkWpTyApps tys
+	; return (GenInst dicts (L span $ HsWrap co_fn (HsVar id))) }
   where
     span = instLocSrcSpan loc
 
@@ -698,11 +698,11 @@ lookupInst (Dict _ pred loc)
 	dfun	   = HsVar dfun_id
 	tys	   = map (substTyVar tenv') tyvars
     ; if null theta then
-    	returnM (SimpleInst (L src_loc $ HsCoerce (mkCoTyApps tys) dfun))
+    	returnM (SimpleInst (L src_loc $ HsWrap (mkWpTyApps tys) dfun))
       else do
     { (dicts, dict_app) <- instCallDicts loc theta
-    ; let co_fn = dict_app <.> mkCoTyApps tys
-    ; returnM (GenInst dicts (L src_loc $ HsCoerce co_fn dfun))
+    ; let co_fn = dict_app <.> mkWpTyApps tys
+    ; returnM (GenInst dicts (L src_loc $ HsWrap co_fn dfun))
     }}}}
 
 ---------------