Inst, OverloadedLit(..),
pprInst, pprInsts, pprInstsInFull, tidyInst, tidyInsts,
- InstanceMapper,
-
newDictFromOld, newDicts, newClassDicts, newDictsAtLoc,
newMethod, newMethodWithGivenTy, newOverloadedLit,
newIPDict, instOverloadedFun,
+ instantiateFdClassTys, instFunDeps, instFunDepsOfTheta,
+ newFunDepFromDict,
tyVarsOfInst, tyVarsOfInsts, tyVarsOfLIE, instLoc, getDictClassTys,
+ getDictPred_maybe, getMethodTheta_maybe,
getFunDeps, getFunDepsOfLIE,
getIPs, getIPsOfLIE,
getAllFunDeps, getAllFunDepsOfLIE,
- partitionLIEbyMeth,
lookupInst, lookupSimpleInst, LookupInstResult(..),
- isDict, isTyVarDict, isStdClassTyVarDict, isMethodFor, notFunDep,
+ isDict, isClassDict, isMethod,
+ isTyVarDict, isStdClassTyVarDict, isMethodFor, notFunDep,
instBindingRequired, instCanBeGeneralised,
- zonkInst, zonkFunDeps, zonkTvFunDeps, instToId, instToIdBndr,
+ zonkInst, zonkInsts, zonkFunDeps, zonkTvFunDeps,
+ instToId, instToIdBndr, ipToId,
InstOrigin(..), InstLoc, pprInstLoc
) where
import HsSyn ( HsLit(..), HsExpr(..) )
import RnHsSyn ( RenamedArithSeqInfo, RenamedHsExpr, RenamedPat )
import TcHsSyn ( TcExpr, TcId,
- mkHsTyApp, mkHsDictApp, zonkId
+ mkHsTyApp, mkHsDictApp, mkHsConApp, zonkId
)
import TcMonad
-import TcEnv ( TcIdSet, tcLookupValueByKey, tcLookupTyConByKey )
+import TcEnv ( TcIdSet, InstEnv, tcGetInstEnv, lookupInstEnv, InstLookupResult(..),
+ tcLookupValueByKey, tcLookupTyConByKey
+ )
import TcType ( TcThetaType,
TcType, TcTauType, TcTyVarSet,
zonkTcTyVars, zonkTcType, zonkTcTypes,
zonkTcThetaType
)
import Bag
-import Class ( classInstEnv, Class )
+import Class ( Class, FunDep )
import FunDeps ( instantiateFdClassTys )
import Id ( Id, idFreeTyVars, idType, mkUserLocal, mkSysLocal )
import PrelInfo ( isStandardClass, isCcallishClass, isNoDictClass )
-import Name ( OccName, Name, mkDictOcc, mkMethodOcc, getOccName, nameUnique )
+import Name ( OccName, Name, mkDictOcc, mkMethodOcc, mkIPOcc,
+ getOccName, nameUnique )
import PprType ( pprPred )
-import InstEnv ( InstEnv, lookupInstEnv )
import SrcLoc ( SrcLoc )
import Type ( Type, PredType(..), ThetaType,
mkTyVarTy, isTyVarTy, mkDictTy, mkPredTy,
splitRhoTy, tyVarsOfType, tyVarsOfTypes, tyVarsOfPred,
mkSynTy, tidyOpenType, tidyOpenTypes
)
-import InstEnv ( InstEnv )
import Subst ( emptyInScopeSet, mkSubst,
substTy, substClasses, mkTyVarSubst, mkTopTyVarSubst
)
import TyCon ( TyCon )
+import Literal ( inIntRange )
import Var ( TyVar )
import VarEnv ( lookupVarEnv, TidyEnv,
lookupSubstEnv, SubstResult(..)
)
import VarSet ( elemVarSet, emptyVarSet, unionVarSet )
import TysPrim ( intPrimTy, floatPrimTy, doublePrimTy )
-import TysWiredIn ( intDataCon, isIntTy, inIntRange,
+import TysWiredIn ( intDataCon, isIntTy,
floatDataCon, isFloatTy,
doubleDataCon, isDoubleTy,
- integerTy, isIntegerTy
+ integerTy, isIntegerTy,
+ voidTy
)
import Unique ( fromRationalClassOpKey, rationalTyConKey,
fromIntClassOpKey, fromIntegerClassOpKey, Unique
)
import Maybes ( expectJust )
-import List ( partition )
import Maybe ( catMaybes )
import Util ( thenCmp, zipWithEqual, mapAccumL )
import Outputable
InstLoc
| FunDep
+ Unique
Class -- the class from which this arises
- [([TcType], [TcType])]
+ [FunDep TcType]
InstLoc
data OverloadedLit
\begin{code}
instance Ord Inst where
compare = cmpInst
-instance Ord PredType where
- compare = cmpPred
instance Eq Inst where
(==) i1 i2 = case i1 `cmpInst` i2 of
EQ -> True
other -> False
-instance Eq PredType where
- (==) p1 p2 = case p1 `cmpPred` p2 of
- EQ -> True
- other -> False
-cmpInst (Dict _ pred1 _) (Dict _ pred2 _)
- = (pred1 `cmpPred` pred2)
-cmpInst (Dict _ _ _) other
- = LT
-
-cmpInst (Method _ _ _ _ _ _) (Dict _ _ _)
- = GT
-cmpInst (Method _ id1 tys1 _ _ _) (Method _ id2 tys2 _ _ _)
- = (id1 `compare` id2) `thenCmp` (tys1 `compare` tys2)
-cmpInst (Method _ _ _ _ _ _) other
- = LT
-
-cmpInst (LitInst _ lit1 ty1 _) (LitInst _ lit2 ty2 _)
- = (lit1 `cmpOverLit` lit2) `thenCmp` (ty1 `compare` ty2)
-cmpInst (LitInst _ _ _ _) (FunDep _ _ _)
- = LT
-cmpInst (LitInst _ _ _ _) other
- = GT
-
-cmpInst (FunDep clas1 fds1 _) (FunDep clas2 fds2 _)
- = (clas1 `compare` clas2) `thenCmp` (fds1 `compare` fds2)
-cmpInst (FunDep _ _ _) other
- = GT
-
-cmpPred (Class c1 tys1) (Class c2 tys2)
- = (c1 `compare` c2) `thenCmp` (tys1 `compare` tys2)
-cmpPred (IParam n1 ty1) (IParam n2 ty2)
- = (n1 `compare` n2) `thenCmp` (ty1 `compare` ty2)
-cmpPred (Class _ _) (IParam _ _) = LT
-cmpPred _ _ = GT
+cmpInst (Dict _ pred1 _) (Dict _ pred2 _) = (pred1 `compare` pred2)
+cmpInst (Dict _ _ _) other = LT
+
+cmpInst (Method _ _ _ _ _ _) (Dict _ _ _) = GT
+cmpInst (Method _ id1 tys1 _ _ _) (Method _ id2 tys2 _ _ _) = (id1 `compare` id2) `thenCmp` (tys1 `compare` tys2)
+cmpInst (Method _ _ _ _ _ _) other = LT
+
+cmpInst (LitInst _ lit1 ty1 _) (LitInst _ lit2 ty2 _) = (lit1 `cmpOverLit` lit2) `thenCmp` (ty1 `compare` ty2)
+cmpInst (LitInst _ _ _ _) (FunDep _ _ _ _) = LT
+cmpInst (LitInst _ _ _ _) other = GT
+
+cmpInst (FunDep _ clas1 fds1 _) (FunDep _ clas2 fds2 _) = (clas1 `compare` clas2) `thenCmp` (fds1 `compare` fds2)
+cmpInst (FunDep _ _ _ _) other = GT
cmpOverLit (OverloadedIntegral i1) (OverloadedIntegral i2) = i1 `compare` i2
cmpOverLit (OverloadedFractional f1) (OverloadedFractional f2) = f1 `compare` f2
instLoc (Dict u pred loc) = loc
instLoc (Method u _ _ _ _ loc) = loc
instLoc (LitInst u lit ty loc) = loc
-instLoc (FunDep _ _ loc) = loc
+instLoc (FunDep _ _ _ loc) = loc
+
+getDictPred_maybe (Dict _ p _) = Just p
+getDictPred_maybe _ = Nothing
+
+getMethodTheta_maybe (Method _ _ _ theta _ _) = Just theta
+getMethodTheta_maybe _ = Nothing
getDictClassTys (Dict u (Class clas tys) _) = (clas, tys)
-getFunDeps (FunDep clas fds _) = Just (clas, fds)
+getFunDeps (FunDep _ clas fds _) = Just (clas, fds)
getFunDeps _ = Nothing
getFunDepsOfLIE lie = catMaybes (map getFunDeps (lieToList lie))
getIPsOfLIE lie = concatMap getIPs (lieToList lie)
-getAllFunDeps (FunDep clas fds _) = fds
+getAllFunDeps (FunDep _ clas fds _) = fds
getAllFunDeps inst = map (\(n,ty) -> ([], [ty])) (getIPs inst)
getAllFunDepsOfLIE lie = concat (map getAllFunDeps (lieToList lie))
-partitionLIEbyMeth pred lie
- = foldlTc (partMethod pred) (emptyLIE, emptyLIE) insts
- where insts = lieToList lie
-
-partMethod pred (ips, lie) m@(Method u id tys theta tau loc)
- = if null ips_ then
- returnTc (ips, consLIE m lie)
- else if null theta_ then
- returnTc (consLIE m ips, lie)
- else
- newMethodWith id tys theta_ tau loc `thenTc` \ new_m2 ->
- let id_m1 = instToIdBndr new_m2
- new_m1 = Method u id_m1 {- tys -} [] ips_ tau loc in
- -- newMethodWith id_m1 tys ips_ tau loc `thenTc` \ new_m1 ->
- returnTc (consLIE new_m1 ips, consLIE new_m2 lie)
- where (ips_, theta_) = partition pred theta
-
tyVarsOfInst :: Inst -> TcTyVarSet
tyVarsOfInst (Dict _ pred _) = tyVarsOfPred pred
tyVarsOfInst (Method _ id tys _ _ _) = tyVarsOfTypes tys `unionVarSet` idFreeTyVars id
-- The id might have free type variables; in the case of
-- locally-overloaded class methods, for example
tyVarsOfInst (LitInst _ _ ty _) = tyVarsOfType ty
-tyVarsOfInst (FunDep _ fds _)
+tyVarsOfInst (FunDep _ _ fds _)
= foldr unionVarSet emptyVarSet (map tyVarsOfFd fds)
where tyVarsOfFd (ts1, ts2) =
tyVarsOfTypes ts1 `unionVarSet` tyVarsOfTypes ts2
~~~~~~~~~~
\begin{code}
isDict :: Inst -> Bool
-isDict (Dict _ (Class _ _) _) = True
-isDict other = False
+isDict (Dict _ _ _) = True
+isDict other = False
+
+isClassDict :: Inst -> Bool
+isClassDict (Dict _ (Class _ _) _) = True
+isClassDict other = False
+
+isMethod :: Inst -> Bool
+isMethod (Method _ _ _ _ _ _) = True
+isMethod other = False
isMethodFor :: TcIdSet -> Inst -> Bool
-isMethodFor ids (Method uniq id tys _ _ loc)
- = id `elemVarSet` ids
-isMethodFor ids inst
- = False
+isMethodFor ids (Method uniq id tys _ _ loc) = id `elemVarSet` ids
+isMethodFor ids inst = False
isTyVarDict :: Inst -> Bool
isTyVarDict (Dict _ (Class _ tys) _) = all isTyVarTy tys
= False
notFunDep :: Inst -> Bool
-notFunDep (FunDep _ _ _) = False
-notFunDep other = True
+notFunDep (FunDep _ _ _ _) = False
+notFunDep other = True
\end{code}
Two predicates which deal with the case where class constraints don't
newMethodWithGivenTy orig id tys theta tau `thenNF_Tc` \ meth_inst ->
returnNF_Tc (unitLIE meth_inst, instToId meth_inst)
-instOverloadedFun orig (HsVar v) arg_tys theta tau
+instOverloadedFun orig v arg_tys theta tau
+-- This is where we introduce new functional dependencies into the LIE
= newMethodWithGivenTy orig v arg_tys theta tau `thenNF_Tc` \ inst ->
instFunDeps orig theta `thenNF_Tc` \ fds ->
- returnNF_Tc (HsVar (instToId inst), mkLIE (inst : fds))
+ returnNF_Tc (instToId inst, mkLIE (inst : fds))
instFunDeps orig theta
- = tcGetInstLoc orig `thenNF_Tc` \ loc ->
+ = tcGetUnique `thenNF_Tc` \ uniq ->
+ tcGetInstLoc orig `thenNF_Tc` \ loc ->
let ifd (Class clas tys) =
let fds = instantiateFdClassTys clas tys in
- if null fds then Nothing else Just (FunDep clas fds loc)
+ if null fds then Nothing else Just (FunDep uniq clas fds loc)
ifd _ = Nothing
in returnNF_Tc (catMaybes (map ifd theta))
+instFunDepsOfTheta theta
+ = let ifd (Class clas tys) = instantiateFdClassTys clas tys
+ ifd (IParam n ty) = [([], [ty])]
+ in concat (map ifd theta)
+
newMethodWithGivenTy orig id tys theta tau
= tcGetInstLoc orig `thenNF_Tc` \ loc ->
newMethodWith id tys theta tau loc
where
intprim_lit = HsLitOut (HsIntPrim i) intPrimTy
integer_lit = HsLitOut (HsInt i) integerTy
- int_lit = HsCon intDataCon [] [intprim_lit]
+ int_lit = mkHsConApp intDataCon [] [intprim_lit]
newOverloadedLit orig lit ty -- The general case
= tcGetInstLoc orig `thenNF_Tc` \ loc ->
\end{code}
\begin{code}
+newFunDepFromDict dict
+ = tcGetUnique `thenNF_Tc` \ uniq ->
+ let (clas, tys) = getDictClassTys dict
+ fds = instantiateFdClassTys clas tys
+ inst = FunDep uniq clas fds (instLoc dict)
+ in
+ if null fds then returnNF_Tc Nothing else returnNF_Tc (Just inst)
+\end{code}
+
+\begin{code}
newIPDict name ty loc
= tcGetUnique `thenNF_Tc` \ new_uniq ->
let d = Dict new_uniq (IParam name ty) loc in
instToId inst = instToIdBndr inst
instToIdBndr :: Inst -> TcId
-instToIdBndr (Dict u (Class clas ty) (_,loc,_))
- = mkUserLocal (mkDictOcc (getOccName clas)) u (mkDictTy clas ty) loc
+instToIdBndr (Dict u (Class clas tys) (_,loc,_))
+ = mkUserLocal (mkDictOcc (getOccName clas)) u (mkDictTy clas tys) loc
instToIdBndr (Dict u (IParam n ty) (_,loc,_))
--- = mkUserLocal (mkIPOcc (getOccName n)) u (mkPredTy (IParam n ty)) loc
- = mkUserLocal (getOccName n) (nameUnique n) (mkPredTy (IParam n ty)) loc
--- = mkVanillaId n ty
+ = ipToId n ty loc
instToIdBndr (Method u id tys theta tau (_,loc,_))
= mkUserLocal (mkMethodOcc (getOccName id)) u tau loc
instToIdBndr (LitInst u list ty loc)
= mkSysLocal SLIT("lit") u ty
-instToIdBndr (FunDep clas fds _)
- = panic "FunDep escaped!!!"
+instToIdBndr (FunDep u clas fds _)
+ = mkSysLocal SLIT("FunDep") u voidTy
+
+ipToId n ty loc
+ = mkUserLocal (mkIPOcc (getOccName n)) (nameUnique n) (mkPredTy (IParam n ty)) loc
\end{code}
= zonkTcType ty `thenNF_Tc` \ new_ty ->
returnNF_Tc (LitInst u lit new_ty loc)
-zonkInst (FunDep clas fds loc)
+zonkInst (FunDep u clas fds loc)
= zonkFunDeps fds `thenNF_Tc` \ fds' ->
- returnNF_Tc (FunDep clas fds' loc)
+ returnNF_Tc (FunDep u clas fds' loc)
+
+zonkPreds preds = mapNF_Tc zonkPred preds
+zonkInsts insts = mapNF_Tc zonkInst insts
zonkFunDeps fds = mapNF_Tc zonkFd fds
where
pprInst (Dict u pred loc) = pprPred pred <+> show_uniq u
-pprInst (Method u id tys _ _ loc)
+pprInst m@(Method u id tys theta tau loc)
= hsep [ppr id, ptext SLIT("at"),
- brackets (interppSP tys),
- show_uniq u]
+ brackets (interppSP tys) {- ,
+ ppr theta, ppr tau,
+ show_uniq u,
+ ppr (instToId m) -}]
-pprInst (FunDep clas fds loc)
+pprInst (FunDep _ clas fds loc)
= hsep [ppr clas, ppr fds]
tidyPred :: TidyEnv -> TcPredType -> (TidyEnv, TcPredType)
(env', tys') = tidyOpenTypes env tys
-- this case shouldn't arise... (we never print fundeps)
-tidyInst env fd@(FunDep clas fds loc)
+tidyInst env fd@(FunDep _ clas fds loc)
= (env, fd)
tidyInsts env insts = mapAccumL tidyInst env insts
%************************************************************************
\begin{code}
-type InstanceMapper = Class -> InstEnv
-\end{code}
-
-A @ClassInstEnv@ lives inside a class, and identifies all the instances
-of that class. The @Id@ inside a ClassInstEnv mapping is the dfun for
-that instance.
-
-There is an important consistency constraint between the @MatchEnv@s
-in and the dfun @Id@s inside them: the free type variables of the
-@Type@ key in the @MatchEnv@ must be a subset of the universally-quantified
-type variables of the dfun. Thus, the @ClassInstEnv@ for @Eq@ might
-contain the following entry:
-@
- [a] ===> dfun_Eq_List :: forall a. Eq a => Eq [a]
-@
-The "a" in the pattern must be one of the forall'd variables in
-the dfun type.
-
-\begin{code}
data LookupInstResult s
= NoInstance
| SimpleInst TcExpr -- Just a variable, type application, or literal
-- Dictionaries
lookupInst dict@(Dict _ (Class clas tys) loc)
- = case lookupInstEnv (ppr clas) (classInstEnv clas) tys of
+ = tcGetInstEnv `thenNF_Tc` \ inst_env ->
+ case lookupInstEnv inst_env clas tys of
- Just (tenv, dfun_id)
+ FoundInst tenv dfun_id
-> let
subst = mkSubst (tyVarsOfTypes tys) tenv
(tyvars, rho) = splitForAllTys (idType dfun_id)
in
returnNF_Tc (GenInst dicts rhs)
- Nothing -> returnNF_Tc NoInstance
+ other -> returnNF_Tc NoInstance
lookupInst dict@(Dict _ _ loc) = returnNF_Tc NoInstance
-- Methods
in_int_range = inIntRange i
intprim_lit = HsLitOut (HsIntPrim i) intPrimTy
integer_lit = HsLitOut (HsInt i) integerTy
- int_lit = HsCon intDataCon [] [intprim_lit]
+ int_lit = mkHsConApp intDataCon [] [intprim_lit]
-- similar idea for overloaded floating point literals: if the literal is
-- *definitely* a float or a double, generate the real thing here.
| isDoubleTy ty = returnNF_Tc (GenInst [] double_lit)
| otherwise
- = tcLookupValueByKey fromRationalClassOpKey `thenNF_Tc` \ from_rational ->
+ = tcLookupValueByKey fromRationalClassOpKey `thenNF_Tc` \ from_rational ->
-- The type Rational isn't wired in so we have to conjure it up
tcLookupTyConByKey rationalTyConKey `thenNF_Tc` \ rational_tycon ->
where
floatprim_lit = HsLitOut (HsFloatPrim f) floatPrimTy
- float_lit = HsCon floatDataCon [] [floatprim_lit]
+ float_lit = mkHsConApp floatDataCon [] [floatprim_lit]
doubleprim_lit = HsLitOut (HsDoublePrim f) doublePrimTy
- double_lit = HsCon doubleDataCon [] [doubleprim_lit]
+ double_lit = mkHsConApp doubleDataCon [] [doubleprim_lit]
-- there are no `instances' of functional dependencies or implicit params
ambiguous dictionaries.
\begin{code}
-lookupSimpleInst :: InstEnv
- -> Class
+lookupSimpleInst :: Class
-> [Type] -- Look up (c,t)
-> NF_TcM s (Maybe [(Class,[Type])]) -- Here are the needed (c,t)s
-lookupSimpleInst class_inst_env clas tys
- = case lookupInstEnv (ppr clas) class_inst_env tys of
- Nothing -> returnNF_Tc Nothing
-
- Just (tenv, dfun)
+lookupSimpleInst clas tys
+ = tcGetInstEnv `thenNF_Tc` \ inst_env ->
+ case lookupInstEnv inst_env clas tys of
+ FoundInst tenv dfun
-> returnNF_Tc (Just (substClasses (mkSubst emptyInScopeSet tenv) theta'))
where
(_, theta, _) = splitSigmaTy (idType dfun)
theta' = map (\(Class clas tys) -> (clas,tys)) theta
+
+ other -> returnNF_Tc Nothing
\end{code}
+
+