From 569b26526403df4d88fe2a6d64c7dade09d003ad Mon Sep 17 00:00:00 2001
From: Richard Eisenberg <eir@cis.upenn.edu>
Date: Fri, 21 Jun 2013 13:54:49 +0100
Subject: [PATCH] Revise implementation of overlapping type family instances.
This commit changes the syntax and story around overlapping type
family instances. Before, we had "unbranched" instances and
"branched" instances. Now, we have closed type families and
open ones.
The behavior of open families is completely unchanged. In particular,
coincident overlap of open type family instances still works, despite
emails to the contrary.
A closed type family is declared like this:
> type family F a where
> F Int = Bool
> F a = Char
The equations are tried in order, from top to bottom, subject to
certain constraints, as described in the user manual. It is not
allowed to declare an instance of a closed family.
---
compiler/coreSyn/CoreLint.lhs | 2 +-
compiler/deSugar/DsMeta.hs | 117 ++-
compiler/hsSyn/Convert.lhs | 15 +-
compiler/hsSyn/HsDecls.lhs | 72 +-
compiler/iface/BinIface.hs | 27 +-
compiler/iface/BuildTyCl.lhs | 2 +-
compiler/iface/IfaceEnv.lhs | 2 +-
compiler/iface/IfaceSyn.lhs | 74 +-
compiler/iface/IfaceType.lhs | 2 +-
compiler/iface/MkIface.lhs | 45 +-
compiler/iface/TcIface.lhs | 44 +-
compiler/iface/TcIface.lhs-boot | 4 +-
compiler/main/GHC.hs | 6 +-
compiler/main/HscMain.hs | 2 +-
compiler/main/HscTypes.lhs | 16 +-
compiler/main/InteractiveEval.hs | 4 +-
compiler/main/PprTyThing.hs | 13 +-
compiler/main/TidyPgm.lhs | 2 +-
compiler/parser/Parser.y.pp | 21 +-
compiler/parser/RdrHsSyn.lhs | 32 +-
compiler/prelude/TysPrim.lhs | 1 +
compiler/rename/RnSource.lhs | 30 +-
compiler/typecheck/FamInst.lhs | 101 +-
compiler/typecheck/TcDeriv.lhs | 21 +-
compiler/typecheck/TcEnv.lhs | 5 +-
compiler/typecheck/TcExpr.lhs | 3 +-
compiler/typecheck/TcGenDeriv.lhs | 5 +-
compiler/typecheck/TcGenGenerics.lhs | 10 +-
compiler/typecheck/TcHsType.lhs | 2 +-
compiler/typecheck/TcInstDcls.lhs | 70 +-
compiler/typecheck/TcInteract.lhs | 15 +-
compiler/typecheck/TcRnDriver.lhs | 28 +-
compiler/typecheck/TcRnTypes.lhs | 2 +-
compiler/typecheck/TcSMonad.lhs | 29 +-
compiler/typecheck/TcSplice.lhs | 67 +-
compiler/typecheck/TcTyClsDecls.lhs | 162 +++-
compiler/typecheck/TcValidity.lhs | 18 +-
compiler/types/CoAxiom.lhs | 84 +-
compiler/types/Coercion.lhs | 60 +-
compiler/types/FamInstEnv.lhs | 876 +++++++++---------
compiler/types/OptCoercion.lhs | 23 +-
compiler/types/TyCon.lhs | 72 +-
compiler/types/Unify.lhs | 110 ++-
compiler/vectorise/Vectorise.hs | 3 +-
compiler/vectorise/Vectorise/Env.hs | 2 +-
.../vectorise/Vectorise/Generic/PAMethods.hs | 4 +-
compiler/vectorise/Vectorise/Generic/PData.hs | 9 +-
compiler/vectorise/Vectorise/Monad/InstEnv.hs | 2 +-
compiler/vectorise/Vectorise/Type/Env.hs | 2 +-
compiler/vectorise/Vectorise/Utils/Base.hs | 6 +-
compiler/vectorise/Vectorise/Utils/PADict.hs | 2 +-
docs/core-spec/CoreLint.ott | 32 +-
docs/core-spec/CoreSyn.ott | 4 +-
docs/core-spec/Makefile | 1 +
docs/core-spec/core-spec.mng | 15 +-
docs/core-spec/core-spec.pdf | Bin 308357 -> 334136 bytes
docs/users_guide/glasgow_exts.xml | 211 +++--
ghc/InteractiveUI.hs | 4 +-
58 files changed, 1428 insertions(+), 1165 deletions(-)
diff --git a/compiler/coreSyn/CoreLint.lhs b/compiler/coreSyn/CoreLint.lhs
index b00b452502b5..f9256e18ad76 100644
--- a/compiler/coreSyn/CoreLint.lhs
+++ b/compiler/coreSyn/CoreLint.lhs
@@ -939,7 +939,7 @@ lintCoercion co@(AxiomInstCo con ind cos)
; let lhs' = Type.substTys subst_l lhs
rhs' = Type.substTy subst_r rhs
; case checkAxInstCo co of
- Just bad_index -> bad_ax $ ptext (sLit "inconsistent with") <+> (ppr bad_index)
+ Just bad_branch -> bad_ax $ ptext (sLit "inconsistent with") <+> (pprCoAxBranch (coAxiomTyCon con) bad_branch)
Nothing -> return ()
; return (typeKind rhs', mkTyConApp (coAxiomTyCon con) lhs', rhs') }
where
diff --git a/compiler/deSugar/DsMeta.hs b/compiler/deSugar/DsMeta.hs
index 8232d91037ef..a60f18ded586 100644
--- a/compiler/deSugar/DsMeta.hs
+++ b/compiler/deSugar/DsMeta.hs
@@ -258,18 +258,29 @@ repSynDecl tc bndrs ty
; repTySyn tc bndrs ty1 }
repFamilyDecl :: LFamilyDecl Name -> DsM (SrcSpan, Core TH.DecQ)
-repFamilyDecl (L loc (FamilyDecl { fdFlavour = flavour,
+repFamilyDecl (L loc (FamilyDecl { fdInfo = info,
fdLName = tc,
fdTyVars = tvs,
fdKindSig = opt_kind }))
= do { tc1 <- lookupLOcc tc -- See note [Binders and occurrences]
; dec <- addTyClTyVarBinds tvs $ \bndrs ->
- do { flav <- repFamilyFlavour flavour
- ; case opt_kind of
- Nothing -> repFamilyNoKind flav tc1 bndrs
- Just ki -> do { ki1 <- repLKind ki
- ; repFamilyKind flav tc1 bndrs ki1 }
- }
+ case (opt_kind, info) of
+ (Nothing, ClosedTypeFamily eqns) ->
+ do { eqns1 <- mapM repTyFamEqn eqns
+ ; eqns2 <- coreList tySynEqnQTyConName eqns1
+ ; repClosedFamilyNoKind tc1 bndrs eqns2 }
+ (Just ki, ClosedTypeFamily eqns) ->
+ do { eqns1 <- mapM repTyFamEqn eqns
+ ; eqns2 <- coreList tySynEqnQTyConName eqns1
+ ; ki1 <- repLKind ki
+ ; repClosedFamilyKind tc1 bndrs ki1 eqns2 }
+ (Nothing, _) ->
+ do { info' <- repFamilyInfo info
+ ; repFamilyNoKind info' tc1 bndrs }
+ (Just ki, _) ->
+ do { info' <- repFamilyInfo info
+ ; ki1 <- repLKind ki
+ ; repFamilyKind info' tc1 bndrs ki1 }
; return (loc, dec)
}
@@ -317,9 +328,10 @@ repLFunDep (L _ (xs, ys)) = do xs' <- repList nameTyConName lookupBinder xs
-- represent family declaration flavours
--
-repFamilyFlavour :: FamilyFlavour -> DsM (Core TH.FamFlavour)
-repFamilyFlavour TypeFamily = rep2 typeFamName []
-repFamilyFlavour DataFamily = rep2 dataFamName []
+repFamilyInfo :: FamilyInfo Name -> DsM (Core TH.FamFlavour)
+repFamilyInfo OpenTypeFamily = rep2 typeFamName []
+repFamilyInfo DataFamily = rep2 dataFamName []
+repFamilyInfo ClosedTypeFamily {} = panic "repFamilyInfo"
-- Represent instance declarations
--
@@ -362,12 +374,11 @@ repClsInstD (ClsInstDecl { cid_poly_ty = ty, cid_binds = binds
Just (tvs, cxt, cls, tys) = splitLHsInstDeclTy_maybe ty
repTyFamInstD :: TyFamInstDecl Name -> DsM (Core TH.DecQ)
-repTyFamInstD decl@(TyFamInstDecl { tfid_eqns = eqns })
+repTyFamInstD decl@(TyFamInstDecl { tfid_eqn = eqn })
= do { let tc_name = tyFamInstDeclLName decl
- ; tc <- lookupLOcc tc_name -- See note [Binders and occurrences]
- ; eqns1 <- mapM repTyFamEqn eqns
- ; eqns2 <- coreList tySynEqnQTyConName eqns1
- ; repTySynInst tc eqns2 }
+ ; tc <- lookupLOcc tc_name -- See note [Binders and occurrences]
+ ; eqn1 <- repTyFamEqn eqn
+ ; repTySynInst tc eqn1 }
repTyFamEqn :: LTyFamInstEqn Name -> DsM (Core TH.TySynEqnQ)
repTyFamEqn (L loc (TyFamInstEqn { tfie_pats = HsWB { hswb_cts = tys
@@ -1688,9 +1699,24 @@ repFamilyKind :: Core TH.FamFlavour -> Core TH.Name -> Core [TH.TyVarBndr]
repFamilyKind (MkC flav) (MkC nm) (MkC tvs) (MkC ki)
= rep2 familyKindDName [flav, nm, tvs, ki]
-repTySynInst :: Core TH.Name -> Core [TH.TySynEqnQ] -> DsM (Core TH.DecQ)
-repTySynInst (MkC nm) (MkC eqns)
- = rep2 tySynInstDName [nm, eqns]
+repTySynInst :: Core TH.Name -> Core TH.TySynEqnQ -> DsM (Core TH.DecQ)
+repTySynInst (MkC nm) (MkC eqn)
+ = rep2 tySynInstDName [nm, eqn]
+
+repClosedFamilyNoKind :: Core TH.Name
+ -> Core [TH.TyVarBndr]
+ -> Core [TH.TySynEqnQ]
+ -> DsM (Core TH.DecQ)
+repClosedFamilyNoKind (MkC nm) (MkC tvs) (MkC eqns)
+ = rep2 closedTypeFamilyNoKindDName [nm, tvs, eqns]
+
+repClosedFamilyKind :: Core TH.Name
+ -> Core [TH.TyVarBndr]
+ -> Core TH.Kind
+ -> Core [TH.TySynEqnQ]
+ -> DsM (Core TH.DecQ)
+repClosedFamilyKind (MkC nm) (MkC tvs) (MkC ki) (MkC eqns)
+ = rep2 closedTypeFamilyKindDName [nm, tvs, ki, eqns]
repTySynEqn :: Core [TH.TypeQ] -> Core TH.TypeQ -> DsM (Core TH.TySynEqnQ)
repTySynEqn (MkC lhs) (MkC rhs)
@@ -1994,7 +2020,8 @@ templateHaskellNames = [
pragInlDName, pragSpecDName, pragSpecInlDName, pragSpecInstDName,
pragRuleDName,
familyNoKindDName, familyKindDName, dataInstDName, newtypeInstDName,
- tySynInstDName, infixLDName, infixRDName, infixNDName,
+ tySynInstDName, closedTypeFamilyKindDName, closedTypeFamilyNoKindDName,
+ infixLDName, infixRDName, infixNDName,
-- Cxt
cxtName,
-- Pred
@@ -2207,6 +2234,7 @@ funDName, valDName, dataDName, newtypeDName, tySynDName, classDName,
instanceDName, sigDName, forImpDName, pragInlDName, pragSpecDName,
pragSpecInlDName, pragSpecInstDName, pragRuleDName, familyNoKindDName,
familyKindDName, dataInstDName, newtypeInstDName, tySynInstDName,
+ closedTypeFamilyKindDName, closedTypeFamilyNoKindDName,
infixLDName, infixRDName, infixNDName :: Name
funDName = libFun (fsLit "funD") funDIdKey
valDName = libFun (fsLit "valD") valDIdKey
@@ -2227,6 +2255,10 @@ familyKindDName = libFun (fsLit "familyKindD") familyKindDIdKey
dataInstDName = libFun (fsLit "dataInstD") dataInstDIdKey
newtypeInstDName = libFun (fsLit "newtypeInstD") newtypeInstDIdKey
tySynInstDName = libFun (fsLit "tySynInstD") tySynInstDIdKey
+closedTypeFamilyKindDName
+ = libFun (fsLit "closedTypeFamilyKindD") closedTypeFamilyKindDIdKey
+closedTypeFamilyNoKindDName
+ = libFun (fsLit "closedTypeFamilyNoKindD") closedTypeFamilyNoKindDIdKey
infixLDName = libFun (fsLit "infixLD") infixLDIdKey
infixRDName = libFun (fsLit "infixRD") infixRDIdKey
infixNDName = libFun (fsLit "infixND") infixNDIdKey
@@ -2543,29 +2575,32 @@ funDIdKey, valDIdKey, dataDIdKey, newtypeDIdKey, tySynDIdKey,
pragSpecDIdKey, pragSpecInlDIdKey, pragSpecInstDIdKey, pragRuleDIdKey,
familyNoKindDIdKey, familyKindDIdKey,
dataInstDIdKey, newtypeInstDIdKey, tySynInstDIdKey,
+ closedTypeFamilyKindDIdKey, closedTypeFamilyNoKindDIdKey,
infixLDIdKey, infixRDIdKey, infixNDIdKey :: Unique
-funDIdKey = mkPreludeMiscIdUnique 330
-valDIdKey = mkPreludeMiscIdUnique 331
-dataDIdKey = mkPreludeMiscIdUnique 332
-newtypeDIdKey = mkPreludeMiscIdUnique 333
-tySynDIdKey = mkPreludeMiscIdUnique 334
-classDIdKey = mkPreludeMiscIdUnique 335
-instanceDIdKey = mkPreludeMiscIdUnique 336
-sigDIdKey = mkPreludeMiscIdUnique 337
-forImpDIdKey = mkPreludeMiscIdUnique 338
-pragInlDIdKey = mkPreludeMiscIdUnique 339
-pragSpecDIdKey = mkPreludeMiscIdUnique 340
-pragSpecInlDIdKey = mkPreludeMiscIdUnique 341
-pragSpecInstDIdKey = mkPreludeMiscIdUnique 412
-pragRuleDIdKey = mkPreludeMiscIdUnique 413
-familyNoKindDIdKey = mkPreludeMiscIdUnique 342
-familyKindDIdKey = mkPreludeMiscIdUnique 343
-dataInstDIdKey = mkPreludeMiscIdUnique 344
-newtypeInstDIdKey = mkPreludeMiscIdUnique 345
-tySynInstDIdKey = mkPreludeMiscIdUnique 346
-infixLDIdKey = mkPreludeMiscIdUnique 347
-infixRDIdKey = mkPreludeMiscIdUnique 348
-infixNDIdKey = mkPreludeMiscIdUnique 349
+funDIdKey = mkPreludeMiscIdUnique 330
+valDIdKey = mkPreludeMiscIdUnique 331
+dataDIdKey = mkPreludeMiscIdUnique 332
+newtypeDIdKey = mkPreludeMiscIdUnique 333
+tySynDIdKey = mkPreludeMiscIdUnique 334
+classDIdKey = mkPreludeMiscIdUnique 335
+instanceDIdKey = mkPreludeMiscIdUnique 336
+sigDIdKey = mkPreludeMiscIdUnique 337
+forImpDIdKey = mkPreludeMiscIdUnique 338
+pragInlDIdKey = mkPreludeMiscIdUnique 339
+pragSpecDIdKey = mkPreludeMiscIdUnique 340
+pragSpecInlDIdKey = mkPreludeMiscIdUnique 341
+pragSpecInstDIdKey = mkPreludeMiscIdUnique 412
+pragRuleDIdKey = mkPreludeMiscIdUnique 413
+familyNoKindDIdKey = mkPreludeMiscIdUnique 342
+familyKindDIdKey = mkPreludeMiscIdUnique 343
+dataInstDIdKey = mkPreludeMiscIdUnique 344
+newtypeInstDIdKey = mkPreludeMiscIdUnique 345
+tySynInstDIdKey = mkPreludeMiscIdUnique 346
+closedTypeFamilyKindDIdKey = mkPreludeMiscIdUnique 347
+closedTypeFamilyNoKindDIdKey = mkPreludeMiscIdUnique 348
+infixLDIdKey = mkPreludeMiscIdUnique 349
+infixRDIdKey = mkPreludeMiscIdUnique 350
+infixNDIdKey = mkPreludeMiscIdUnique 351
-- type Cxt = ...
cxtIdKey :: Unique
diff --git a/compiler/hsSyn/Convert.lhs b/compiler/hsSyn/Convert.lhs
index 8caf9873367e..a07fafe00d4a 100644
--- a/compiler/hsSyn/Convert.lhs
+++ b/compiler/hsSyn/Convert.lhs
@@ -215,7 +215,7 @@ cvtDec (FamilyD flav tc tvs kind)
; kind' <- cvtMaybeKind kind
; returnL $ TyClD (FamDecl (FamilyDecl (cvtFamFlavour flav) tc' tvs' kind')) }
where
- cvtFamFlavour TypeFam = TypeFamily
+ cvtFamFlavour TypeFam = OpenTypeFamily
cvtFamFlavour DataFam = DataFamily
cvtDec (DataInstD ctxt tc tys constrs derivs)
@@ -243,13 +243,18 @@ cvtDec (NewtypeInstD ctxt tc tys constr derivs)
{ dfid_inst = DataFamInstDecl { dfid_tycon = tc', dfid_pats = typats'
, dfid_defn = defn, dfid_fvs = placeHolderNames } }}
-cvtDec (TySynInstD tc eqns)
+cvtDec (TySynInstD tc eqn)
= do { tc' <- tconNameL tc
- ; eqns' <- mapM (cvtTySynEqn tc') eqns
+ ; eqn' <- cvtTySynEqn tc' eqn
; returnL $ InstD $ TyFamInstD
- { tfid_inst = TyFamInstDecl { tfid_eqns = eqns'
- , tfid_group = (length eqns' /= 1)
+ { tfid_inst = TyFamInstDecl { tfid_eqn = eqn'
, tfid_fvs = placeHolderNames } } }
+
+cvtDec (ClosedTypeFamilyD tc tyvars mkind eqns)
+ = do { (_, tc', tvs') <- cvt_tycl_hdr [] tc tyvars
+ ; mkind' <- cvtMaybeKind mkind
+ ; eqns' <- mapM (cvtTySynEqn tc') eqns
+ ; returnL $ TyClD (FamDecl (FamilyDecl (ClosedTypeFamily eqns') tc' tvs' mkind')) }
----------------
cvtTySynEqn :: Located RdrName -> TySynEqn -> CvtM (LTyFamInstEqn RdrName)
cvtTySynEqn tc (TySynEqn lhs rhs)
diff --git a/compiler/hsSyn/HsDecls.lhs b/compiler/hsSyn/HsDecls.lhs
index ce391c73e248..e088af7c18f8 100644
--- a/compiler/hsSyn/HsDecls.lhs
+++ b/compiler/hsSyn/HsDecls.lhs
@@ -24,7 +24,7 @@ module HsDecls (
FamilyDecl(..), LFamilyDecl,
-- ** Instance declarations
- InstDecl(..), LInstDecl, NewOrData(..), FamilyFlavour(..),
+ InstDecl(..), LInstDecl, NewOrData(..), FamilyInfo(..),
TyFamInstDecl(..), LTyFamInstDecl, instDeclDataFamInsts,
DataFamInstDecl(..), LDataFamInstDecl, pprDataFamInstFlavour,
TyFamInstEqn(..), LTyFamInstEqn,
@@ -470,16 +470,17 @@ data TyClDecl name
type LFamilyDecl name = Located (FamilyDecl name)
data FamilyDecl name = FamilyDecl
- { fdFlavour :: FamilyFlavour -- type or data
+ { fdInfo :: FamilyInfo name -- type or data, closed or open
, fdLName :: Located name -- type constructor
, fdTyVars :: LHsTyVarBndrs name -- type variables
, fdKindSig :: Maybe (LHsKind name) } -- result kind
deriving( Data, Typeable )
-data FamilyFlavour
- = TypeFamily
- | DataFamily
- deriving( Data, Typeable, Eq )
+data FamilyInfo name
+ = DataFamily
+ | OpenTypeFamily
+ | ClosedTypeFamily [LTyFamInstEqn name]
+ deriving( Data, Typeable )
\end{code}
@@ -510,12 +511,15 @@ isFamilyDecl _other = False
-- | type family declaration
isTypeFamilyDecl :: TyClDecl name -> Bool
-isTypeFamilyDecl (FamDecl d) = fdFlavour d == TypeFamily
-isTypeFamilyDecl _other = False
+isTypeFamilyDecl (FamDecl (FamilyDecl { fdInfo = info })) = case info of
+ OpenTypeFamily -> True
+ ClosedTypeFamily {} -> True
+ _ -> False
+isTypeFamilyDecl _ = False
-- | data family declaration
isDataFamilyDecl :: TyClDecl name -> Bool
-isDataFamilyDecl (FamDecl d) = fdFlavour d == DataFamily
+isDataFamilyDecl (FamDecl (FamilyDecl { fdInfo = DataFamily })) = True
isDataFamilyDecl _other = False
\end{code}
@@ -528,11 +532,9 @@ tyFamInstDeclName = unLoc . tyFamInstDeclLName
tyFamInstDeclLName :: OutputableBndr name
=> TyFamInstDecl name -> Located name
-tyFamInstDeclLName (TyFamInstDecl { tfid_eqns =
- (L _ (TyFamInstEqn { tfie_tycon = ln })) : _ })
- -- there may be more than one equation, but grab the name from the first
+tyFamInstDeclLName (TyFamInstDecl { tfid_eqn =
+ (L _ (TyFamInstEqn { tfie_tycon = ln })) })
= ln
-tyFamInstDeclLName decl = pprPanic "tyFamInstDeclLName" (ppr decl)
tyClDeclLName :: TyClDecl name -> Located name
tyClDeclLName (FamDecl { tcdFam = FamilyDecl { fdLName = ln } }) = ln
@@ -598,17 +600,26 @@ instance OutputableBndr name
<+> pprFundeps (map unLoc fds)
instance (OutputableBndr name) => Outputable (FamilyDecl name) where
- ppr (FamilyDecl { fdFlavour = flavour, fdLName = ltycon,
+ ppr (FamilyDecl { fdInfo = info, fdLName = ltycon,
fdTyVars = tyvars, fdKindSig = mb_kind})
- = ppr flavour <+> pp_vanilla_decl_head ltycon tyvars [] <+> pp_kind
+ = vcat [ pprFlavour info <+> pp_vanilla_decl_head ltycon tyvars [] <+> pp_kind <+> pp_where
+ , nest 2 $ pp_eqns ]
where
pp_kind = case mb_kind of
Nothing -> empty
Just kind -> dcolon <+> ppr kind
+ (pp_where, pp_eqns) = case info of
+ ClosedTypeFamily eqns -> ( ptext (sLit "where")
+ , vcat $ map ppr eqns )
+ _ -> (empty, empty)
+
+pprFlavour :: FamilyInfo name -> SDoc
+pprFlavour DataFamily = ptext (sLit "data family")
+pprFlavour OpenTypeFamily = ptext (sLit "type family")
+pprFlavour (ClosedTypeFamily {}) = ptext (sLit "type family")
-instance Outputable FamilyFlavour where
- ppr TypeFamily = ptext (sLit "type family")
- ppr DataFamily = ptext (sLit "data family")
+instance Outputable (FamilyInfo name) where
+ ppr = pprFlavour
pp_vanilla_decl_head :: OutputableBndr name
=> Located name
@@ -838,10 +849,9 @@ pprConDecl decl@(ConDecl { con_details = InfixCon ty1 ty2, con_res = ResTyGADT {
\begin{code}
----------------- Type synonym family instances -------------
--- See note [Family instance equation groups]
type LTyFamInstEqn name = Located (TyFamInstEqn name)
--- | One equation in a family instance declaration
+-- | One equation in a type family instance declaration
data TyFamInstEqn name
= TyFamInstEqn
{ tfie_tycon :: Located name
@@ -854,15 +864,10 @@ data TyFamInstEqn name
type LTyFamInstDecl name = Located (TyFamInstDecl name)
data TyFamInstDecl name
= TyFamInstDecl
- { tfid_eqns :: [LTyFamInstEqn name] -- ^ list of (possibly-overlapping) eqns
- -- Always non-empty
- , tfid_group :: Bool -- Was this declared with the "where" syntax?
- , tfid_fvs :: NameSet } -- The group is type-checked as one,
- -- so one NameSet will do
- -- INVARIANT: tfid_group == False --> length tfid_eqns == 1
+ { tfid_eqn :: LTyFamInstEqn name
+ , tfid_fvs :: NameSet }
deriving( Typeable, Data )
-
----------------- Data family instances -------------
type LDataFamInstDecl name = Located (DataFamInstDecl name)
@@ -925,24 +930,13 @@ tvs are fv(pat_tys), *including* ones that are already in scope
so that we can compare the type patter in the 'instance' decl and
in the associated 'type' decl
-Note [Family instance equation groups]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-A TyFamInstDecl contains a list of FamInstEqn's, one for each
-equation defined in the instance group. For a standalone
-instance declaration, this list contains exactly one element.
-It is not possible for this list to have 0 elements --
-'type instance where' without anything else is not allowed.
-
\begin{code}
instance (OutputableBndr name) => Outputable (TyFamInstDecl name) where
ppr = pprTyFamInstDecl TopLevel
pprTyFamInstDecl :: OutputableBndr name => TopLevelFlag -> TyFamInstDecl name -> SDoc
-pprTyFamInstDecl top_lvl (TyFamInstDecl { tfid_group = False, tfid_eqns = [eqn] })
+pprTyFamInstDecl top_lvl (TyFamInstDecl { tfid_eqn = eqn })
= ptext (sLit "type") <+> ppr_instance_keyword top_lvl <+> (ppr eqn)
-pprTyFamInstDecl top_lvl (TyFamInstDecl { tfid_eqns = eqns })
- = hang (ptext (sLit "type") <+> ppr_instance_keyword top_lvl <+> ptext (sLit "where"))
- 2 (vcat (map ppr eqns))
ppr_instance_keyword :: TopLevelFlag -> SDoc
ppr_instance_keyword TopLevel = ptext (sLit "instance")
diff --git a/compiler/iface/BinIface.hs b/compiler/iface/BinIface.hs
index 9390ee437757..ba1a7e28e2b4 100644
--- a/compiler/iface/BinIface.hs
+++ b/compiler/iface/BinIface.hs
@@ -1307,27 +1307,30 @@ instance Binary IfaceDecl where
return (IfaceAxiom occ a2 a3)
instance Binary IfaceAxBranch where
- put_ bh (IfaceAxBranch a1 a2 a3) = do
+ put_ bh (IfaceAxBranch a1 a2 a3 a4) = do
put_ bh a1
put_ bh a2
put_ bh a3
+ put_ bh a4
get bh = do
a1 <- get bh
a2 <- get bh
a3 <- get bh
- return (IfaceAxBranch a1 a2 a3)
+ a4 <- get bh
+ return (IfaceAxBranch a1 a2 a3 a4)
-instance Binary ty => Binary (SynTyConRhs ty) where
- put_ bh (SynFamilyTyCon a b) = putByte bh 0 >> put_ bh a >> put_ bh b
- put_ bh (SynonymTyCon ty) = putByte bh 1 >> put_ bh ty
+instance Binary IfaceSynTyConRhs where
+ put_ bh IfaceOpenSynFamilyTyCon = putByte bh 0
+ put_ bh (IfaceClosedSynFamilyTyCon ax) = putByte bh 1 >> put_ bh ax
+ put_ bh (IfaceSynonymTyCon ty) = putByte bh 2 >> put_ bh ty
get bh = do { h <- getByte bh
; case h of
- 0 -> do { a <- get bh
- ; b <- get bh
- ; return (SynFamilyTyCon a b) }
+ 0 -> do { return IfaceOpenSynFamilyTyCon }
+ 1 -> do { ax <- get bh
+ ; return (IfaceClosedSynFamilyTyCon ax) }
_ -> do { ty <- get bh
- ; return (SynonymTyCon ty) } }
+ ; return (IfaceSynonymTyCon ty) } }
instance Binary IfaceClsInst where
put_ bh (IfaceClsInst cls tys dfun flag orph) = do
@@ -1345,19 +1348,17 @@ instance Binary IfaceClsInst where
return (IfaceClsInst cls tys dfun flag orph)
instance Binary IfaceFamInst where
- put_ bh (IfaceFamInst fam group tys name orph) = do
+ put_ bh (IfaceFamInst fam tys name orph) = do
put_ bh fam
- put_ bh group
put_ bh tys
put_ bh name
put_ bh orph
get bh = do
fam <- get bh
- group <- get bh
tys <- get bh
name <- get bh
orph <- get bh
- return (IfaceFamInst fam group tys name orph)
+ return (IfaceFamInst fam tys name orph)
instance Binary OverlapFlag where
put_ bh (NoOverlap b) = putByte bh 0 >> put_ bh b
diff --git a/compiler/iface/BuildTyCl.lhs b/compiler/iface/BuildTyCl.lhs
index d5e4a4a62e85..a541e32b7b4e 100644
--- a/compiler/iface/BuildTyCl.lhs
+++ b/compiler/iface/BuildTyCl.lhs
@@ -47,7 +47,7 @@ import Outputable
\begin{code}
------------------------------------------------------
buildSynTyCon :: Name -> [TyVar]
- -> SynTyConRhs Type
+ -> SynTyConRhs
-> Kind -- ^ Kind of the RHS
-> TyConParent
-> TcRnIf m n TyCon
diff --git a/compiler/iface/IfaceEnv.lhs b/compiler/iface/IfaceEnv.lhs
index 81f1b33e96c2..0441fdbf4188 100644
--- a/compiler/iface/IfaceEnv.lhs
+++ b/compiler/iface/IfaceEnv.lhs
@@ -57,7 +57,7 @@ import Data.IORef ( atomicModifyIORef, readIORef )
Note [The Name Cache]
~~~~~~~~~~~~~~~~~~~~~
-The Name Cache makes sure that, during any invocation of GHC, each
+The Name Cache makes sure that, during any invovcation of GHC, each
External Name "M.x" has one, and only one globally-agreed Unique.
* The first time we come across M.x we make up a Unique and record that
diff --git a/compiler/iface/IfaceSyn.lhs b/compiler/iface/IfaceSyn.lhs
index 7632b38d81bc..ad327d642826 100644
--- a/compiler/iface/IfaceSyn.lhs
+++ b/compiler/iface/IfaceSyn.lhs
@@ -14,7 +14,7 @@
module IfaceSyn (
module IfaceType,
- IfaceDecl(..), IfaceClassOp(..), IfaceAT(..),
+ IfaceDecl(..), IfaceSynTyConRhs(..), IfaceClassOp(..), IfaceAT(..),
IfaceConDecl(..), IfaceConDecls(..),
IfaceExpr(..), IfaceAlt, IfaceLetBndr(..),
IfaceBinding(..), IfaceConAlt(..),
@@ -36,13 +36,13 @@ module IfaceSyn (
#include "HsVersions.h"
-import TyCon( SynTyConRhs(..) )
import IfaceType
import PprCore() -- Printing DFunArgs
import Demand
import Annotations
import Class
import NameSet
+import CoAxiom ( BranchIndex )
import Name
import CostCentre
import Literal
@@ -91,7 +91,7 @@ data IfaceDecl
| IfaceSyn { ifName :: OccName, -- Type constructor
ifTyVars :: [IfaceTvBndr], -- Type variables
ifSynKind :: IfaceKind, -- Kind of the *rhs* (not of the tycon)
- ifSynRhs :: SynTyConRhs IfaceType }
+ ifSynRhs :: IfaceSynTyConRhs }
| IfaceClass { ifCtxt :: IfaceContext, -- Context...
ifName :: OccName, -- Name of the class TyCon
@@ -112,6 +112,11 @@ data IfaceDecl
-- beyond .NET
ifExtName :: Maybe FastString }
+data IfaceSynTyConRhs
+ = IfaceOpenSynFamilyTyCon
+ | IfaceClosedSynFamilyTyCon IfExtName -- name of associated axiom
+ | IfaceSynonymTyCon IfaceType
+
data IfaceClassOp = IfaceClassOp OccName DefMethSpec IfaceType
-- Nothing => no default method
-- Just False => ordinary polymorphic default method
@@ -122,13 +127,35 @@ data IfaceAT = IfaceAT IfaceDecl [IfaceAxBranch]
-- Just ds => default associated type instance from these templates
instance Outputable IfaceAxBranch where
- ppr (IfaceAxBranch { ifaxbTyVars = tvs, ifaxbLHS = pat_tys, ifaxbRHS = ty })
- = ppr tvs <+> hsep (map ppr pat_tys) <+> char '=' <+> ppr ty
+ ppr = pprAxBranch Nothing
+
+pprAxBranch :: Maybe IfaceTyCon -> IfaceAxBranch -> SDoc
+pprAxBranch mtycon (IfaceAxBranch { ifaxbTyVars = tvs
+ , ifaxbLHS = pat_tys
+ , ifaxbRHS = ty
+ , ifaxbIncomps = incomps })
+ = ppr tvs <+> ppr_lhs <+> char '=' <+> ppr ty $+$
+ nest 4 maybe_incomps
+ where
+ ppr_lhs
+ | Just tycon <- mtycon
+ = ppr (IfaceTyConApp tycon pat_tys)
+ | otherwise
+ = hsep (map ppr pat_tys)
+
+ maybe_incomps
+ | [] <- incomps
+ = empty
+
+ | otherwise
+ = parens (ptext (sLit "incompatible indices:") <+> ppr incomps)
-- this is just like CoAxBranch
-data IfaceAxBranch = IfaceAxBranch { ifaxbTyVars :: [IfaceTvBndr]
- , ifaxbLHS :: [IfaceType]
- , ifaxbRHS :: IfaceType }
+data IfaceAxBranch = IfaceAxBranch { ifaxbTyVars :: [IfaceTvBndr]
+ , ifaxbLHS :: [IfaceType]
+ , ifaxbRHS :: IfaceType
+ , ifaxbIncomps :: [BranchIndex] }
+ -- See Note [Storing compatibility] in CoAxiom
data IfaceConDecls
= IfAbstractTyCon Bool -- c.f TyCon.AbstractTyCon
@@ -173,12 +200,10 @@ data IfaceClsInst
-- and if the head does not change it won't be used if it wasn't before
-- The ifFamInstTys field of IfaceFamInst contains a list of the rough
--- match types, one per branch... but each "rough match types" is itself
--- a list of Maybe IfaceTyCon. So, we get [[Maybe IfaceTyCon]].
+-- match types
data IfaceFamInst
= IfaceFamInst { ifFamInstFam :: IfExtName -- Family name
- , ifFamInstBranched :: Bool -- Is this branched?
- , ifFamInstTys :: [[Maybe IfaceTyCon]] -- See above
+ , ifFamInstTys :: [Maybe IfaceTyCon] -- See above
, ifFamInstAxiom :: IfExtName -- The axiom
, ifFamInstOrph :: Maybe OccName -- Just like IfaceClsInst
}
@@ -497,15 +522,20 @@ pprIfaceDecl (IfaceForeign {ifName = tycon})
pprIfaceDecl (IfaceSyn {ifName = tycon,
ifTyVars = tyvars,
- ifSynRhs = SynonymTyCon mono_ty})
+ ifSynRhs = IfaceSynonymTyCon mono_ty})
= hang (ptext (sLit "type") <+> pprIfaceDeclHead [] tycon tyvars)
4 (vcat [equals <+> ppr mono_ty])
pprIfaceDecl (IfaceSyn {ifName = tycon, ifTyVars = tyvars,
- ifSynRhs = SynFamilyTyCon {}, ifSynKind = kind })
+ ifSynRhs = IfaceOpenSynFamilyTyCon, ifSynKind = kind })
= hang (ptext (sLit "type family") <+> pprIfaceDeclHead [] tycon tyvars)
4 (dcolon <+> ppr kind)
+pprIfaceDecl (IfaceSyn {ifName = tycon, ifTyVars = tyvars,
+ ifSynRhs = IfaceClosedSynFamilyTyCon {}, ifSynKind = kind })
+ = hang (ptext (sLit "closed type family") <+> pprIfaceDeclHead [] tycon tyvars)
+ 4 (dcolon <+> ppr kind)
+
pprIfaceDecl (IfaceData {ifName = tycon, ifCType = cType,
ifCtxt = context,
ifTyVars = tyvars, ifCons = condecls,
@@ -535,10 +565,7 @@ pprIfaceDecl (IfaceClass {ifCtxt = context, ifName = clas, ifTyVars = tyvars,
pprIfaceDecl (IfaceAxiom {ifName = name, ifTyCon = tycon, ifAxBranches = branches })
= hang (ptext (sLit "axiom") <+> ppr name <> colon)
- 2 (vcat $ map ppr_branch branches)
- where
- ppr_branch (IfaceAxBranch { ifaxbTyVars = tyvars, ifaxbLHS = lhs, ifaxbRHS = rhs })
- = pprIfaceTvBndrs tyvars <> dot <+> ppr (IfaceTyConApp tycon lhs) <+> text "~#" <+> ppr rhs
+ 2 (vcat $ map (pprAxBranch $ Just tycon) branches)
pprCType :: Maybe CType -> SDoc
pprCType Nothing = ptext (sLit "No C type associated")
@@ -623,10 +650,10 @@ instance Outputable IfaceClsInst where
2 (equals <+> ppr dfun_id)
instance Outputable IfaceFamInst where
- ppr (IfaceFamInst {ifFamInstFam = fam, ifFamInstTys = mb_tcss,
+ ppr (IfaceFamInst {ifFamInstFam = fam, ifFamInstTys = mb_tcs,
ifFamInstAxiom = tycon_ax})
= hang (ptext (sLit "family instance") <+>
- ppr fam <+> pprWithCommas (brackets . pprWithCommas ppr_rough) mb_tcss)
+ ppr fam <+> pprWithCommas (brackets . ppr_rough) mb_tcs)
2 (equals <+> ppr tycon_ax)
ppr_rough :: Maybe IfaceTyCon -> SDoc
@@ -820,9 +847,10 @@ freeNamesIfIdDetails (IfRecSelId tc _) = freeNamesIfTc tc
freeNamesIfIdDetails _ = emptyNameSet
-- All other changes are handled via the version info on the tycon
-freeNamesIfSynRhs :: SynTyConRhs IfaceType -> NameSet
-freeNamesIfSynRhs (SynonymTyCon ty) = freeNamesIfType ty
-freeNamesIfSynRhs _ = emptyNameSet
+freeNamesIfSynRhs :: IfaceSynTyConRhs -> NameSet
+freeNamesIfSynRhs (IfaceSynonymTyCon ty) = freeNamesIfType ty
+freeNamesIfSynRhs IfaceOpenSynFamilyTyCon = emptyNameSet
+freeNamesIfSynRhs (IfaceClosedSynFamilyTyCon ax) = unitNameSet ax
freeNamesIfContext :: IfaceContext -> NameSet
freeNamesIfContext = fnList freeNamesIfType
diff --git a/compiler/iface/IfaceType.lhs b/compiler/iface/IfaceType.lhs
index 103d336dbbb9..480eb7e0bac7 100644
--- a/compiler/iface/IfaceType.lhs
+++ b/compiler/iface/IfaceType.lhs
@@ -90,7 +90,7 @@ newtype IfaceTyCon = IfaceTc { ifaceTyConName :: IfExtName }
-- Coercion constructors
data IfaceCoCon
- = IfaceCoAx IfExtName Int -- Int is 0-indexed branch number
+ = IfaceCoAx IfExtName BranchIndex -- BranchIndex is 0-indexed branch number
| IfaceReflCo | IfaceUnsafeCo | IfaceSymCo
| IfaceTransCo | IfaceInstCo
| IfaceNthCo Int | IfaceLRCo LeftOrRight
diff --git a/compiler/iface/MkIface.lhs b/compiler/iface/MkIface.lhs
index 13b64cdb2559..d9bd6fc94189 100644
--- a/compiler/iface/MkIface.lhs
+++ b/compiler/iface/MkIface.lhs
@@ -311,7 +311,6 @@ mkIface_ hsc_env maybe_old_fingerprint
mi_warn_fn = mkIfaceWarnCache warns,
mi_fix_fn = mkIfaceFixCache fixities }
}
-
; (new_iface, no_change_at_all)
<- {-# SCC "versioninfo" #-}
addFingerprints hsc_env maybe_old_fingerprint
@@ -1445,16 +1444,33 @@ coAxiomToIfaceDecl :: CoAxiom br -> IfaceDecl
coAxiomToIfaceDecl ax@(CoAxiom { co_ax_tc = tycon, co_ax_branches = branches })
= IfaceAxiom { ifName = name
, ifTyCon = toIfaceTyCon tycon
- , ifAxBranches = brListMap (coAxBranchToIfaceBranch emptyTidyEnv) branches }
+ , ifAxBranches = brListMap (coAxBranchToIfaceBranch
+ emptyTidyEnv
+ (brListMap coAxBranchLHS branches)) branches }
where
name = getOccName ax
-
-coAxBranchToIfaceBranch :: TidyEnv -> CoAxBranch -> IfaceAxBranch
-coAxBranchToIfaceBranch env0 (CoAxBranch { cab_tvs = tvs, cab_lhs = lhs, cab_rhs = rhs })
+-- 2nd parameter is the list of branch LHSs, for conversion from incompatible branches
+-- to incompatible indices
+-- See [Storing compatibility] in CoAxiom
+coAxBranchToIfaceBranch :: TidyEnv -> [[Type]] -> CoAxBranch -> IfaceAxBranch
+coAxBranchToIfaceBranch env0 lhs_s
+ branch@(CoAxBranch { cab_incomps = incomps })
+ = (coAxBranchToIfaceBranch' env0 branch) { ifaxbIncomps = iface_incomps }
+ where
+ iface_incomps = map (expectJust "iface_incomps"
+ . (flip findIndex lhs_s
+ . eqTypes)
+ . coAxBranchLHS) incomps
+
+-- use this one for standalone branches without incompatibles
+coAxBranchToIfaceBranch' :: TidyEnv -> CoAxBranch -> IfaceAxBranch
+coAxBranchToIfaceBranch' env0
+ (CoAxBranch { cab_tvs = tvs, cab_lhs = lhs, cab_rhs = rhs })
= IfaceAxBranch { ifaxbTyVars = toIfaceTvBndrs tv_bndrs
, ifaxbLHS = map (tidyToIfaceType env1) lhs
- , ifaxbRHS = tidyToIfaceType env1 rhs }
+ , ifaxbRHS = tidyToIfaceType env1 rhs
+ , ifaxbIncomps = [] }
where
(env1, tv_bndrs) = tidyTyVarBndrs env0 tvs
@@ -1491,8 +1507,9 @@ tyConToIfaceDecl env tycon
where
(env1, tyvars) = tidyTyClTyVarBndrs env (tyConTyVars tycon)
- to_ifsyn_rhs (SynFamilyTyCon a b) = SynFamilyTyCon a b
- to_ifsyn_rhs (SynonymTyCon ty) = SynonymTyCon (tidyToIfaceType env1 ty)
+ to_ifsyn_rhs OpenSynFamilyTyCon = IfaceOpenSynFamilyTyCon
+ to_ifsyn_rhs (ClosedSynFamilyTyCon ax) = IfaceClosedSynFamilyTyCon (coAxiomName ax)
+ to_ifsyn_rhs (SynonymTyCon ty) = IfaceSynonymTyCon (tidyToIfaceType env1 ty)
ifaceConDecls (NewTyCon { data_con = con }) = IfNewTyCon (ifaceConDecl con)
ifaceConDecls (DataTyCon { data_cons = cons }) = IfDataTyCon (map ifaceConDecl cons)
@@ -1550,7 +1567,7 @@ classToIfaceDecl env clas
toIfaceAT :: ClassATItem -> IfaceAT
toIfaceAT (tc, defs)
- = IfaceAT (tyConToIfaceDecl env1 tc) (map (coAxBranchToIfaceBranch env1) defs)
+ = IfaceAT (tyConToIfaceDecl env1 tc) (map (coAxBranchToIfaceBranch' env1) defs)
toIfaceClassOp (sel_id, def_meth)
= ASSERT(sel_tyvars == clas_tyvars)
@@ -1638,19 +1655,15 @@ instanceToIfaceInst (ClsInst { is_dfun = dfun_id, is_flag = oflag
(n : _) -> Just (nameOccName n)
--------------------------
-famInstToIfaceFamInst :: FamInst br -> IfaceFamInst
+famInstToIfaceFamInst :: FamInst -> IfaceFamInst
famInstToIfaceFamInst (FamInst { fi_axiom = axiom,
- fi_branched = branched,
fi_fam = fam,
- fi_branches = branches })
+ fi_tcs = roughs })
= IfaceFamInst { ifFamInstAxiom = coAxiomName axiom
, ifFamInstFam = fam
- , ifFamInstBranched = branched
- , ifFamInstTys = map (map do_rough) roughs
+ , ifFamInstTys = map do_rough roughs
, ifFamInstOrph = orph }
where
- roughs = brListMap famInstBranchRoughMatch branches
-
do_rough Nothing = Nothing
do_rough (Just n) = Just (toIfaceTyCon_name n)
diff --git a/compiler/iface/TcIface.lhs b/compiler/iface/TcIface.lhs
index 4c7435a554e9..af9d8f609c82 100644
--- a/compiler/iface/TcIface.lhs
+++ b/compiler/iface/TcIface.lhs
@@ -490,9 +490,12 @@ tc_iface_decl parent _ (IfaceSyn {ifName = occ_name, ifTyVars = tv_bndrs,
; return (ATyCon tycon) }
where
mk_doc n = ptext (sLit "Type syonym") <+> ppr n
- tc_syn_rhs (SynFamilyTyCon a b) = return (SynFamilyTyCon a b)
- tc_syn_rhs (SynonymTyCon ty) = do { rhs_ty <- tcIfaceType ty
- ; return (SynonymTyCon rhs_ty) }
+ tc_syn_rhs IfaceOpenSynFamilyTyCon = return OpenSynFamilyTyCon
+ tc_syn_rhs (IfaceClosedSynFamilyTyCon ax_name)
+ = do { ax <- tcIfaceCoAxiom ax_name
+ ; return (ClosedSynFamilyTyCon ax) }
+ tc_syn_rhs (IfaceSynonymTyCon ty) = do { rhs_ty <- tcIfaceType ty
+ ; return (SynonymTyCon rhs_ty) }
tc_iface_decl _parent ignore_prags
(IfaceClass {ifCtxt = rdr_ctxt, ifName = tc_occ,
@@ -535,7 +538,7 @@ tc_iface_decl _parent ignore_prags
tc_at cls (IfaceAT tc_decl defs_decls)
= do ATyCon tc <- tc_iface_decl (AssocFamilyTyCon cls) ignore_prags tc_decl
- defs <- mapM tc_ax_branch defs_decls
+ defs <- foldlM tc_ax_branches [] defs_decls
return (tc, defs)
mk_op_doc op_name op_ty = ptext (sLit "Class op") <+> sep [ppr op_name, ppr op_ty]
@@ -552,23 +555,28 @@ tc_iface_decl _ _ (IfaceForeign {ifName = rdr_name, ifExtName = ext_name})
tc_iface_decl _ _ (IfaceAxiom {ifName = ax_occ, ifTyCon = tc, ifAxBranches = branches})
= do { tc_name <- lookupIfaceTop ax_occ
; tc_tycon <- tcIfaceTyCon tc
- ; tc_branches <- mapM tc_ax_branch branches
- ; let axiom = CoAxiom { co_ax_unique = nameUnique tc_name
+ ; tc_branches <- foldlM tc_ax_branches [] branches
+ ; let axiom = computeAxiomIncomps $
+ CoAxiom { co_ax_unique = nameUnique tc_name
, co_ax_name = tc_name
, co_ax_tc = tc_tycon
, co_ax_branches = toBranchList tc_branches
, co_ax_implicit = False }
; return (ACoAxiom axiom) }
-tc_ax_branch :: IfaceAxBranch -> IfL CoAxBranch
-tc_ax_branch (IfaceAxBranch { ifaxbTyVars = tv_bndrs, ifaxbLHS = lhs, ifaxbRHS = rhs })
+tc_ax_branches :: [CoAxBranch] -> IfaceAxBranch -> IfL [CoAxBranch]
+tc_ax_branches prev_branches
+ (IfaceAxBranch { ifaxbTyVars = tv_bndrs, ifaxbLHS = lhs, ifaxbRHS = rhs
+ , ifaxbIncomps = incomps })
= bindIfaceTyVars tv_bndrs $ \ tvs -> do -- Variables will all be fresh
{ tc_lhs <- mapM tcIfaceType lhs
; tc_rhs <- tcIfaceType rhs
- ; return (CoAxBranch { cab_loc = noSrcSpan
- , cab_tvs = tvs
- , cab_lhs = tc_lhs
- , cab_rhs = tc_rhs } ) }
+ ; let br = CoAxBranch { cab_loc = noSrcSpan
+ , cab_tvs = tvs
+ , cab_lhs = tc_lhs
+ , cab_rhs = tc_rhs
+ , cab_incomps = map (prev_branches !!) incomps }
+ ; return (prev_branches ++ [br]) }
tcIfaceDataCons :: Name -> TyCon -> [TyVar] -> IfaceConDecls -> IfL AlgTyConRhs
tcIfaceDataCons tycon_name tycon _ if_cons
@@ -664,13 +672,15 @@ tcIfaceInst (IfaceClsInst { ifDFun = dfun_occ, ifOFlag = oflag
; let mb_tcs' = map (fmap ifaceTyConName) mb_tcs
; return (mkImportedInstance cls mb_tcs' dfun oflag) }
-tcIfaceFamInst :: IfaceFamInst -> IfL (FamInst Branched)
-tcIfaceFamInst (IfaceFamInst { ifFamInstFam = fam, ifFamInstTys = mb_tcss
- , ifFamInstBranched = branched, ifFamInstAxiom = axiom_name } )
+tcIfaceFamInst :: IfaceFamInst -> IfL FamInst
+tcIfaceFamInst (IfaceFamInst { ifFamInstFam = fam, ifFamInstTys = mb_tcs
+ , ifFamInstAxiom = axiom_name } )
= do { axiom' <- forkM (ptext (sLit "Axiom") <+> ppr axiom_name) $
tcIfaceCoAxiom axiom_name
- ; let mb_tcss' = map (map (fmap ifaceTyConName)) mb_tcss
- ; return (mkImportedFamInst fam branched mb_tcss' axiom') }
+ -- will panic if branched, but that's OK
+ ; let axiom'' = toUnbranchedAxiom axiom'
+ mb_tcs' = map (fmap ifaceTyConName) mb_tcs
+ ; return (mkImportedFamInst fam mb_tcs' axiom'') }
\end{code}
diff --git a/compiler/iface/TcIface.lhs-boot b/compiler/iface/TcIface.lhs-boot
index 58df07cdc438..591419a25191 100644
--- a/compiler/iface/TcIface.lhs-boot
+++ b/compiler/iface/TcIface.lhs-boot
@@ -5,7 +5,7 @@ import IfaceSyn ( IfaceDecl, IfaceClsInst, IfaceFamInst, IfaceRule, IfaceAnno
import TypeRep ( TyThing )
import TcRnTypes ( IfL )
import InstEnv ( ClsInst )
-import FamInstEnv ( FamInst, Branched )
+import FamInstEnv ( FamInst )
import CoreSyn ( CoreRule )
import HscTypes ( TypeEnv, VectInfo, IfaceVectInfo )
import Module ( Module )
@@ -15,7 +15,7 @@ tcIfaceDecl :: Bool -> IfaceDecl -> IfL TyThing
tcIfaceRules :: Bool -> [IfaceRule] -> IfL [CoreRule]
tcIfaceVectInfo :: Module -> TypeEnv -> IfaceVectInfo -> IfL VectInfo
tcIfaceInst :: IfaceClsInst -> IfL ClsInst
-tcIfaceFamInst :: IfaceFamInst -> IfL (FamInst Branched)
+tcIfaceFamInst :: IfaceFamInst -> IfL FamInst
tcIfaceAnnotations :: [IfaceAnnotation] -> IfL [Annotation]
\end{code}
diff --git a/compiler/main/GHC.hs b/compiler/main/GHC.hs
index a4aba138b919..39e1e0a4537a 100644
--- a/compiler/main/GHC.hs
+++ b/compiler/main/GHC.hs
@@ -157,7 +157,7 @@ module GHC (
TyCon,
tyConTyVars, tyConDataCons, tyConArity,
isClassTyCon, isSynTyCon, isNewTyCon, isPrimTyCon, isFunTyCon,
- isFamilyTyCon, tyConClass_maybe,
+ isFamilyTyCon, isOpenFamilyTyCon, tyConClass_maybe,
synTyConRhs_maybe, synTyConDefn_maybe, synTyConResKind,
-- ** Type variables
@@ -182,7 +182,7 @@ module GHC (
pprInstance, pprInstanceHdr,
pprFamInst,
- FamInst, Branched,
+ FamInst,
-- ** Types and Kinds
Type, splitForAllTys, funResultTy,
@@ -1004,7 +1004,7 @@ getBindings = withSession $ \hsc_env ->
return $ icInScopeTTs $ hsc_IC hsc_env
-- | Return the instances for the current interactive session.
-getInsts :: GhcMonad m => m ([ClsInst], [FamInst Branched])
+getInsts :: GhcMonad m => m ([ClsInst], [FamInst])
getInsts = withSession $ \hsc_env ->
return $ ic_instances (hsc_IC hsc_env)
diff --git a/compiler/main/HscMain.hs b/compiler/main/HscMain.hs
index caa68d5ddf0a..d94fc7842f39 100644
--- a/compiler/main/HscMain.hs
+++ b/compiler/main/HscMain.hs
@@ -303,7 +303,7 @@ hscTcRcLookupName hsc_env0 name = runInteractiveHsc hsc_env0 $ do
-- "name not found", and the Maybe in the return type
-- is used to indicate that.
-hscTcRnGetInfo :: HscEnv -> Name -> IO (Maybe (TyThing, Fixity, [ClsInst], [FamInst Branched]))
+hscTcRnGetInfo :: HscEnv -> Name -> IO (Maybe (TyThing, Fixity, [ClsInst], [FamInst]))
hscTcRnGetInfo hsc_env0 name = runInteractiveHsc hsc_env0 $ do
hsc_env <- getHscEnv
ioMsgMaybe' $ tcRnGetInfo hsc_env name
diff --git a/compiler/main/HscTypes.lhs b/compiler/main/HscTypes.lhs
index 28134e15450e..163af051e8d3 100644
--- a/compiler/main/HscTypes.lhs
+++ b/compiler/main/HscTypes.lhs
@@ -456,7 +456,7 @@ lookupIfaceByModule dflags hpt pit mod
-- modules imported by this one, directly or indirectly, and are in the Home
-- Package Table. This ensures that we don't see instances from modules @--make@
-- compiled before this one, but which are not below this one.
-hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([ClsInst], [FamInst Branched])
+hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([ClsInst], [FamInst])
hptInstances hsc_env want_this_module
= let (insts, famInsts) = unzip $ flip hptAllThings hsc_env $ \mod_info -> do
guard (want_this_module (moduleName (mi_module (hm_iface mod_info))))
@@ -777,7 +777,7 @@ data ModDetails
md_exports :: [AvailInfo],
md_types :: !TypeEnv, -- ^ Local type environment for this particular module
md_insts :: ![ClsInst], -- ^ 'DFunId's for the instances in this module
- md_fam_insts :: ![FamInst Branched],
+ md_fam_insts :: ![FamInst],
md_rules :: ![CoreRule], -- ^ Domain may include 'Id's from other modules
md_anns :: ![Annotation], -- ^ Annotations present in this module: currently
-- they only annotate things also declared in this module
@@ -823,7 +823,7 @@ data ModGuts
mg_tcs :: ![TyCon], -- ^ TyCons declared in this module
-- (includes TyCons for classes)
mg_insts :: ![ClsInst], -- ^ Class instances declared in this module
- mg_fam_insts :: ![FamInst Branched],
+ mg_fam_insts :: ![FamInst],
-- ^ Family instances declared in this module
mg_rules :: ![CoreRule], -- ^ Before the core pipeline starts, contains
-- See Note [Overall plumbing for rules] in Rules.lhs
@@ -953,7 +953,7 @@ data InteractiveContext
-- ^ Variables defined automatically by the system (e.g.
-- record field selectors). See Notes [ic_sys_vars]
- ic_instances :: ([ClsInst], [FamInst Branched]),
+ ic_instances :: ([ClsInst], [FamInst]),
-- ^ All instances and family instances created during
-- this session. These are grabbed en masse after each
-- update to be sure that proper overlapping is retained.
@@ -1280,10 +1280,12 @@ implicitTyConThings tc
extras_plus :: TyThing -> [TyThing]
extras_plus thing = thing : implicitTyThings thing
--- For newtypes (only) add the implicit coercion tycon
+-- For newtypes and closed type families (only) add the implicit coercion tycon
implicitCoTyCon :: TyCon -> [TyThing]
implicitCoTyCon tc
| Just co <- newTyConCo_maybe tc = [ACoAxiom $ toBranchedAxiom co]
+ | Just co <- isClosedSynFamilyTyCon_maybe tc
+ = [ACoAxiom co]
| otherwise = []
-- | Returns @True@ if there should be no interface-file declaration
@@ -1379,12 +1381,12 @@ mkTypeEnvWithImplicits things =
`plusNameEnv`
mkTypeEnv (concatMap implicitTyThings things)
-typeEnvFromEntities :: [Id] -> [TyCon] -> [FamInst Branched] -> TypeEnv
+typeEnvFromEntities :: [Id] -> [TyCon] -> [FamInst] -> TypeEnv
typeEnvFromEntities ids tcs famInsts =
mkTypeEnv ( map AnId ids
++ map ATyCon all_tcs
++ concatMap implicitTyConThings all_tcs
- ++ map (ACoAxiom . famInstAxiom) famInsts
+ ++ map (ACoAxiom . toBranchedAxiom . famInstAxiom) famInsts
)
where
all_tcs = tcs ++ famInstsRepTyCons famInsts
diff --git a/compiler/main/InteractiveEval.hs b/compiler/main/InteractiveEval.hs
index 391de5a42f75..635c194a9278 100644
--- a/compiler/main/InteractiveEval.hs
+++ b/compiler/main/InteractiveEval.hs
@@ -45,7 +45,7 @@ import HscMain
import HsSyn
import HscTypes
import InstEnv
-import FamInstEnv ( FamInst, Branched, orphNamesOfFamInst )
+import FamInstEnv ( FamInst, orphNamesOfFamInst )
import TyCon
import Type hiding( typeKind )
import TcType hiding( typeKind )
@@ -890,7 +890,7 @@ moduleIsInterpreted modl = withSession $ \h ->
-- are in scope (qualified or otherwise). Otherwise we list a whole lot too many!
-- The exact choice of which ones to show, and which to hide, is a judgement call.
-- (see Trac #1581)
-getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing,Fixity,[ClsInst],[FamInst Branched]))
+getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing,Fixity,[ClsInst],[FamInst]))
getInfo allInfo name
= withSession $ \hsc_env ->
do mb_stuff <- liftIO $ hscTcRnGetInfo hsc_env name
diff --git a/compiler/main/PprTyThing.hs b/compiler/main/PprTyThing.hs
index 5145f5600547..56d7afc4fa98 100644
--- a/compiler/main/PprTyThing.hs
+++ b/compiler/main/PprTyThing.hs
@@ -29,7 +29,8 @@ import GHC ( TyThing(..) )
import DataCon
import Id
import TyCon
-import Coercion( pprCoAxiom )
+import Coercion( pprCoAxiom, pprCoAxBranch )
+import CoAxiom( CoAxiom(..), brListMap )
import HscTypes( tyThingParent_maybe )
import Type( tidyTopType, tidyOpenType )
import TypeRep( pprTvBndrs )
@@ -175,10 +176,14 @@ pprTyCon :: PrintExplicitForalls -> ShowSub -> TyCon -> SDoc
pprTyCon pefas ss tyCon
| Just syn_rhs <- GHC.synTyConRhs_maybe tyCon
= case syn_rhs of
- SynFamilyTyCon {} -> pprTyConHdr pefas tyCon <+> dcolon <+>
- pprTypeForUser pefas (GHC.synTyConResKind tyCon)
+ OpenSynFamilyTyCon -> pprTyConHdr pefas tyCon <+> dcolon <+>
+ pprTypeForUser pefas (GHC.synTyConResKind tyCon)
+ ClosedSynFamilyTyCon (CoAxiom { co_ax_branches = branches }) ->
+ hang (pprTyConHdr pefas tyCon <+> dcolon <+>
+ pprTypeForUser pefas (GHC.synTyConResKind tyCon) <+> ptext (sLit "where"))
+ 2 (vcat (brListMap (pprCoAxBranch tyCon) branches))
SynonymTyCon rhs_ty -> hang (pprTyConHdr pefas tyCon <+> equals)
- 2 (ppr rhs_ty) -- Don't suppress foralls on RHS type!
+ 2 (ppr rhs_ty) -- Don't suppress foralls on RHS type!
-- e.g. type T = forall a. a->a
| Just cls <- GHC.tyConClass_maybe tyCon
= pprClass pefas ss cls
diff --git a/compiler/main/TidyPgm.lhs b/compiler/main/TidyPgm.lhs
index 4608a21e8c9c..be4c68327653 100644
--- a/compiler/main/TidyPgm.lhs
+++ b/compiler/main/TidyPgm.lhs
@@ -152,7 +152,7 @@ mkBootModDetailsTc hsc_env
}
where
-mkBootTypeEnv :: NameSet -> [Id] -> [TyCon] -> [FamInst Branched] -> TypeEnv
+mkBootTypeEnv :: NameSet -> [Id] -> [TyCon] -> [FamInst] -> TypeEnv
mkBootTypeEnv exports ids tcs fam_insts
= tidyTypeEnv True $
typeEnvFromEntities final_ids tcs fam_insts
diff --git a/compiler/parser/Parser.y.pp b/compiler/parser/Parser.y.pp
index 483ed87591ab..1545aa27f433 100644
--- a/compiler/parser/Parser.y.pp
+++ b/compiler/parser/Parser.y.pp
@@ -644,10 +644,10 @@ ty_decl :: { LTyClDecl RdrName }
{% mkTySynonym (comb2 $1 $4) $2 $4 }
-- type family declarations
- | 'type' 'family' type opt_kind_sig
+ | 'type' 'family' type opt_kind_sig where_type_family
-- Note the use of type for the head; this allows
-- infix type constructors to be declared
- {% do { L loc decl <- mkFamDecl (comb3 $1 $3 $4) TypeFamily $3 (unLoc $4)
+ {% do { L loc decl <- mkFamDecl (comb4 $1 $3 $4 $5) (unLoc $5) $3 (unLoc $4)
; return (L loc (FamDecl decl)) } }
-- ordinary data type or newtype declaration
@@ -684,9 +684,6 @@ inst_decl :: { LInstDecl RdrName }
{% do { L loc tfi <- mkTyFamInst (comb2 $1 $3) $3
; return (L loc (TyFamInstD { tfid_inst = tfi })) } }
- | 'type' 'instance' 'where' ty_fam_inst_eqn_list
- { LL (TyFamInstD { tfid_inst = mkTyFamInstGroup (unLoc $4) }) }
-
-- data/newtype instance declaration
| data_or_newtype 'instance' tycl_hdr constrs deriving
{% do { L loc d <- mkFamInstData (comb4 $1 $3 $4 $5) (unLoc $1) Nothing $3
@@ -701,14 +698,19 @@ inst_decl :: { LInstDecl RdrName }
(unLoc $4) (unLoc $5) (unLoc $6)
; return (L loc (DataFamInstD { dfid_inst = d })) } }
--- Type instance groups
+-- Closed type families
+
+where_type_family :: { Located (FamilyInfo RdrName) }
+ : {- empty -} { noLoc OpenTypeFamily }
+ | 'where' ty_fam_inst_eqn_list
+ { LL (ClosedTypeFamily (reverse (unLoc $2))) }
ty_fam_inst_eqn_list :: { Located [LTyFamInstEqn RdrName] }
: '{' ty_fam_inst_eqns '}' { LL (unLoc $2) }
| vocurly ty_fam_inst_eqns close { $2 }
ty_fam_inst_eqns :: { Located [LTyFamInstEqn RdrName] }
- : ty_fam_inst_eqn ';' ty_fam_inst_eqns { LL ($1 : unLoc $3) }
+ : ty_fam_inst_eqns ';' ty_fam_inst_eqn { LL ($3 : unLoc $1) }
| ty_fam_inst_eqns ';' { LL (unLoc $1) }
| ty_fam_inst_eqn { LL [$1] }
@@ -716,7 +718,8 @@ ty_fam_inst_eqn :: { LTyFamInstEqn RdrName }
: type '=' ctype
-- Note the use of type for the head; this allows
-- infix type constructors and type patterns
- {% mkTyFamInstEqn (comb2 $1 $3) $1 $3 }
+ {% do { eqn <- mkTyFamInstEqn $1 $3
+ ; return (LL eqn) } }
-- Associated type family declarations
--
@@ -732,7 +735,7 @@ at_decl_cls :: { LHsDecl RdrName }
: 'type' type opt_kind_sig
-- Note the use of type for the head; this allows
-- infix type constructors to be declared.
- {% do { L loc decl <- mkFamDecl (comb3 $1 $2 $3) TypeFamily $2 (unLoc $3)
+ {% do { L loc decl <- mkFamDecl (comb3 $1 $2 $3) OpenTypeFamily $2 (unLoc $3)
; return (L loc (TyClD (FamDecl decl))) } }
| 'data' type opt_kind_sig
diff --git a/compiler/parser/RdrHsSyn.lhs b/compiler/parser/RdrHsSyn.lhs
index 3695daef5855..e8c23cad52b6 100644
--- a/compiler/parser/RdrHsSyn.lhs
+++ b/compiler/parser/RdrHsSyn.lhs
@@ -10,7 +10,7 @@ module RdrHsSyn (
mkHsDo, mkHsSplice, mkTopSpliceDecl,
mkClassDecl,
mkTyData, mkFamInstData,
- mkTySynonym, mkTyFamInstEqn, mkTyFamInstGroup,
+ mkTySynonym, mkTyFamInstEqn,
mkTyFamInst,
mkFamDecl,
splitCon, mkInlinePragma,
@@ -178,39 +178,31 @@ mkTySynonym loc lhs rhs
; return (L loc (SynDecl { tcdLName = tc, tcdTyVars = tyvars,
tcdRhs = rhs, tcdFVs = placeHolderNames })) }
-mkTyFamInstEqn :: SrcSpan
+mkTyFamInstEqn :: LHsType RdrName
-> LHsType RdrName
- -> LHsType RdrName
- -> P (LTyFamInstEqn RdrName)
-mkTyFamInstEqn loc lhs rhs
+ -> P (TyFamInstEqn RdrName)
+mkTyFamInstEqn lhs rhs
= do { (tc, tparams) <- checkTyClHdr lhs
- ; return (L loc (TyFamInstEqn { tfie_tycon = tc
- , tfie_pats = mkHsWithBndrs tparams
- , tfie_rhs = rhs })) }
+ ; return (TyFamInstEqn { tfie_tycon = tc
+ , tfie_pats = mkHsWithBndrs tparams
+ , tfie_rhs = rhs }) }
mkTyFamInst :: SrcSpan
-> LTyFamInstEqn RdrName
-> P (LTyFamInstDecl RdrName)
mkTyFamInst loc eqn
- = return (L loc (TyFamInstDecl { tfid_eqns = [eqn]
- , tfid_group = False
- , tfid_fvs = placeHolderNames }))
-
-mkTyFamInstGroup :: [LTyFamInstEqn RdrName]
- -> TyFamInstDecl RdrName
-mkTyFamInstGroup eqns = TyFamInstDecl { tfid_eqns = eqns
- , tfid_group = True
- , tfid_fvs = placeHolderNames }
+ = return (L loc (TyFamInstDecl { tfid_eqn = eqn
+ , tfid_fvs = placeHolderNames }))
mkFamDecl :: SrcSpan
- -> FamilyFlavour
+ -> FamilyInfo RdrName
-> LHsType RdrName -- LHS
-> Maybe (LHsKind RdrName) -- Optional kind signature
-> P (LFamilyDecl RdrName)
-mkFamDecl loc flavour lhs ksig
+mkFamDecl loc info lhs ksig
= do { (tc, tparams) <- checkTyClHdr lhs
; tyvars <- checkTyVars lhs tparams
- ; return (L loc (FamilyDecl flavour tc tyvars ksig)) }
+ ; return (L loc (FamilyDecl info tc tyvars ksig)) }
mkTopSpliceDecl :: LHsExpr RdrName -> HsDecl RdrName
-- If the user wrote
diff --git a/compiler/prelude/TysPrim.lhs b/compiler/prelude/TysPrim.lhs
index f702689e935f..a10300a99cfe 100644
--- a/compiler/prelude/TysPrim.lhs
+++ b/compiler/prelude/TysPrim.lhs
@@ -731,6 +731,7 @@ anyTyCon = mkLiftedPrimTyCon anyTyConName kind 1 PtrRep
where kind = ForAllTy kKiVar (mkTyVarTy kKiVar)
{- Can't do this yet without messing up kind proxies
+-- RAE: I think you can now.
anyTyCon :: TyCon
anyTyCon = mkSynTyCon anyTyConName kind [kKiVar]
syn_rhs
diff --git a/compiler/rename/RnSource.lhs b/compiler/rename/RnSource.lhs
index cc410388dffd..e1236cac10c5 100644
--- a/compiler/rename/RnSource.lhs
+++ b/compiler/rename/RnSource.lhs
@@ -542,10 +542,9 @@ rnFamInstDecl doc mb_cls tycon pats payload rnPayload
rnTyFamInstDecl :: Maybe (Name, [Name])
-> TyFamInstDecl RdrName
-> RnM (TyFamInstDecl Name, FreeVars)
-rnTyFamInstDecl mb_cls (TyFamInstDecl { tfid_eqns = eqns, tfid_group = group })
- = do { (eqns', fvs) <- rnList (rnTyFamInstEqn mb_cls) eqns
- ; return (TyFamInstDecl { tfid_eqns = eqns'
- , tfid_group = group
+rnTyFamInstDecl mb_cls (TyFamInstDecl { tfid_eqn = L loc eqn })
+ = do { (eqn', fvs) <- rnTyFamInstEqn mb_cls eqn
+ ; return (TyFamInstDecl { tfid_eqn = L loc eqn'
, tfid_fvs = fvs }, fvs) }
rnTyFamInstEqn :: Maybe (Name, [Name])
@@ -1044,16 +1043,27 @@ rnFamDecl :: Maybe Name
-> FamilyDecl RdrName
-> RnM (FamilyDecl Name, FreeVars)
rnFamDecl mb_cls (FamilyDecl { fdLName = tycon, fdTyVars = tyvars
- , fdFlavour = flav, fdKindSig = kind })
- = bindHsTyVars fmly_doc mb_cls kvs tyvars $ \tyvars' ->
- do { tycon' <- lookupLocatedTopBndrRn tycon
- ; (kind', fv_kind) <- rnLHsMaybeKind fmly_doc kind
+ , fdInfo = info, fdKindSig = kind })
+ = do { ((tycon', tyvars', kind'), fv1) <-
+ bindHsTyVars fmly_doc mb_cls kvs tyvars $ \tyvars' ->
+ do { tycon' <- lookupLocatedTopBndrRn tycon
+ ; (kind', fv_kind) <- rnLHsMaybeKind fmly_doc kind
+ ; return ((tycon', tyvars', kind'), fv_kind) }
+ ; (info', fv2) <- rn_info info
; return (FamilyDecl { fdLName = tycon', fdTyVars = tyvars'
- , fdFlavour = flav, fdKindSig = kind' }
- , fv_kind ) }
+ , fdInfo = info', fdKindSig = kind' }
+ , fv1 `plusFV` fv2) }
where
fmly_doc = TyFamilyCtx tycon
kvs = extractRdrKindSigVars kind
+
+ rn_info (ClosedTypeFamily eqns)
+ = do { (eqns', fvs) <- rnList (rnTyFamInstEqn Nothing) eqns
+ -- no class context,
+ ; return (ClosedTypeFamily eqns', fvs) }
+ rn_info OpenTypeFamily = return (OpenTypeFamily, emptyFVs)
+ rn_info DataFamily = return (DataFamily, emptyFVs)
+
\end{code}
Note [Stupid theta]
diff --git a/compiler/typecheck/FamInst.lhs b/compiler/typecheck/FamInst.lhs
index 44a0cefac501..3f220b1339d6 100644
--- a/compiler/typecheck/FamInst.lhs
+++ b/compiler/typecheck/FamInst.lhs
@@ -35,6 +35,7 @@ import Maybes
import TcMType
import TcType
import Name
+import VarSet -- RAE
import Control.Monad
import Data.Map (Map)
import qualified Data.Map as Map
@@ -53,34 +54,27 @@ import qualified Data.Map as Map
-- creates the fresh variables and applies the necessary substitution
-- It is defined here to avoid a dependency from FamInstEnv on the monad
-- code.
-newFamInst :: FamFlavor -> Bool -> CoAxiom br -> TcRnIf gbl lcl(FamInst br)
+
+newFamInst :: FamFlavor -> CoAxiom Unbranched -> TcRnIf gbl lcl FamInst
-- Freshen the type variables of the FamInst branches
-- Called from the vectoriser monad too, hence the rather general type
-newFamInst flavor is_branched axiom@(CoAxiom { co_ax_tc = fam_tc
- , co_ax_branches = ax_branches })
- = do { fam_branches <- go ax_branches
- ; return (FamInst { fi_fam = tyConName fam_tc
+newFamInst flavor axiom@(CoAxiom { co_ax_branches = FirstBranch branch
+ , co_ax_tc = fam_tc })
+ = do { (subst, tvs') <- tcInstSkolTyVarsLoc loc tvs
+ ; return (FamInst { fi_fam = fam_tc_name
, fi_flavor = flavor
- , fi_branches = fam_branches
- , fi_branched = is_branched
+ , fi_tcs = roughMatchTcs lhs
+ , fi_tvs = tvs'
+ , fi_tys = substTys subst lhs
+ , fi_rhs = substTy subst rhs
, fi_axiom = axiom }) }
where
- go :: BranchList CoAxBranch br -> TcRnIf gbl lcl (BranchList FamInstBranch br)
- go (FirstBranch br) = do { br' <- go_branch br
- ; return (FirstBranch br') }
- go (NextBranch br brs) = do { br' <- go_branch br
- ; brs' <- go brs
- ;return (NextBranch br' brs') }
- go_branch :: CoAxBranch -> TcRnIf gbl lcl FamInstBranch
- go_branch (CoAxBranch { cab_tvs = tvs1
- , cab_lhs = lhs
- , cab_loc = loc
- , cab_rhs = rhs })
- = do { (subst, tvs2) <- tcInstSkolTyVarsLoc loc tvs1
- ; return (FamInstBranch { fib_tvs = tvs2
- , fib_lhs = substTys subst lhs
- , fib_rhs = substTy subst rhs
- , fib_tcs = roughMatchTcs lhs }) }
+ fam_tc_name = tyConName fam_tc
+ CoAxBranch { cab_loc = loc
+ , cab_tvs = tvs
+ , cab_lhs = lhs
+ , cab_rhs = rhs } = branch
+
\end{code}
@@ -218,14 +212,14 @@ which implies that :R42T was declared as 'data instance T [a]'.
\begin{code}
tcLookupFamInst :: TyCon -> [Type] -> TcM (Maybe FamInstMatch)
tcLookupFamInst tycon tys
- | not (isFamilyTyCon tycon)
+ | not (isOpenFamilyTyCon tycon)
= return Nothing
| otherwise
= do { instEnv <- tcGetFamInstEnvs
; let mb_match = lookupFamInstEnv instEnv tycon tys
--- ; traceTc "lookupFamInst" ((ppr tycon <+> ppr tys) $$
--- pprTvBndrs (varSetElems (tyVarsOfTypes tys)) $$
--- ppr mb_match $$ ppr instEnv)
+ ; traceTc "lookupFamInst" ((ppr tycon <+> ppr tys) $$
+ pprTvBndrs (varSetElems (tyVarsOfTypes tys)) $$
+ ppr mb_match $$ ppr instEnv)
; case mb_match of
[] -> return Nothing
(match:_)
@@ -242,7 +236,7 @@ tcLookupFamInst tycon tys
\begin{code}
-- Add new locally-defined family instances
-tcExtendLocalFamInstEnv :: [FamInst br] -> TcM a -> TcM a
+tcExtendLocalFamInstEnv :: [FamInst] -> TcM a -> TcM a
tcExtendLocalFamInstEnv fam_insts thing_inside
= do { env <- getGblEnv
; (inst_env', fam_insts') <- foldlM addLocalFamInst
@@ -257,7 +251,7 @@ tcExtendLocalFamInstEnv fam_insts thing_inside
-- and then add it to the home inst env
-- This must be lazy in the fam_inst arguments, see Note [Lazy axiom match]
-- in FamInstEnv.lhs
-addLocalFamInst :: (FamInstEnv,[FamInst Branched]) -> FamInst br -> TcM (FamInstEnv, [FamInst Branched])
+addLocalFamInst :: (FamInstEnv,[FamInst]) -> FamInst -> TcM (FamInstEnv, [FamInst])
addLocalFamInst (home_fie, my_fis) fam_inst
-- home_fie includes home package and this module
-- my_fies is just the ones from this module
@@ -276,13 +270,12 @@ addLocalFamInst (home_fie, my_fis) fam_inst
-- overlaps correctly
; eps <- getEps
; let inst_envs = (eps_fam_inst_env eps, home_fie')
- fam_inst' = toBranchedFamInst fam_inst
- home_fie'' = extendFamInstEnv home_fie fam_inst'
+ home_fie'' = extendFamInstEnv home_fie fam_inst
-- Check for conflicting instance decls
- ; no_conflict <- checkForConflicts inst_envs fam_inst'
+ ; no_conflict <- checkForConflicts inst_envs fam_inst
; if no_conflict then
- return (home_fie'', fam_inst' : my_fis')
+ return (home_fie'', fam_inst : my_fis')
else
return (home_fie, my_fis) }
@@ -298,39 +291,35 @@ Check whether a single family instance conflicts with those in two instance
environments (one for the EPS and one for the HPT).
\begin{code}
-checkForConflicts :: FamInstEnvs -> FamInst Branched -> TcM Bool
-checkForConflicts inst_envs fam_inst@(FamInst { fi_branches = branches
- , fi_branched = branched })
- = do { let conflicts = brListMap (lookupFamInstEnvConflicts inst_envs branched fam_tc) branches
- no_conflicts = all null conflicts
- ; traceTc "checkForConflicts" (ppr conflicts $$ ppr fam_inst $$ ppr inst_envs)
- ; unless no_conflicts $
- zipWithM_ (conflictInstErr fam_inst) (brListIndices branches) conflicts
+checkForConflicts :: FamInstEnvs -> FamInst -> TcM Bool
+checkForConflicts inst_envs fam_inst
+ = do { let conflicts = lookupFamInstEnvConflicts inst_envs fam_inst
+ no_conflicts = null conflicts
+ ; traceTc "checkForConflicts" (ppr (map fim_instance conflicts) $$
+ ppr fam_inst $$ ppr inst_envs)
+ ; unless no_conflicts $ conflictInstErr fam_inst conflicts
; return no_conflicts }
- where fam_tc = famInstTyCon fam_inst
-conflictInstErr :: FamInst Branched -> BranchIndex -> [FamInstMatch] -> TcRn ()
-conflictInstErr fam_inst branch conflictingMatch
- | (FamInstMatch { fim_instance = confInst
- , fim_index = confIndex }) : _ <- conflictingMatch
+conflictInstErr :: FamInst -> [FamInstMatch] -> TcRn ()
+conflictInstErr fam_inst conflictingMatch
+ | (FamInstMatch { fim_instance = confInst }) : _ <- conflictingMatch
= addFamInstsErr (ptext (sLit "Conflicting family instance declarations:"))
- [(fam_inst, branch),
- (confInst, confIndex) ]
- | otherwise -- no conflict on this branch; see Trac #7560
- = return ()
+ [fam_inst, confInst]
+ | otherwise
+ = panic "conflictInstErr"
-addFamInstsErr :: SDoc -> [(FamInst Branched, Int)] -> TcRn ()
+addFamInstsErr :: SDoc -> [FamInst] -> TcRn ()
addFamInstsErr herald insts
= ASSERT( not (null insts) )
setSrcSpan srcSpan $ addErr $
hang herald
- 2 (vcat [ pprCoAxBranchHdr (famInstAxiom fi) index
- | (fi,index) <- sorted ])
+ 2 (vcat [ pprCoAxBranchHdr (famInstAxiom fi) 0
+ | fi <- sorted ])
where
- getSpan = getSrcLoc . famInstAxiom . fst
+ getSpan = getSrcLoc . famInstAxiom
sorted = sortWith getSpan insts
- (fi1,ix1) = head sorted
- srcSpan = coAxBranchSpan (coAxiomNthBranch (famInstAxiom fi1) ix1)
+ fi1 = head sorted
+ srcSpan = coAxBranchSpan (coAxiomSingleBranch (famInstAxiom fi1))
-- The sortWith just arranges that instances are dislayed in order
-- of source location, which reduced wobbling in error messages,
-- and is better for users
diff --git a/compiler/typecheck/TcDeriv.lhs b/compiler/typecheck/TcDeriv.lhs
index ac2d81072afa..21e2bbb5b9fd 100644
--- a/compiler/typecheck/TcDeriv.lhs
+++ b/compiler/typecheck/TcDeriv.lhs
@@ -46,7 +46,6 @@ import RdrName
import Name
import NameSet
import TyCon
-import CoAxiom
import TcType
import Var
import VarSet
@@ -355,7 +354,7 @@ tcDeriving tycl_decls inst_decls deriv_decls
where
ddump_deriving :: Bag (InstInfo Name) -> HsValBinds Name
-> Bag TyCon -- ^ Empty data constructors
- -> Bag (FamInst Unbranched) -- ^ Rep type family instances
+ -> Bag (FamInst) -- ^ Rep type family instances
-> SDoc
ddump_deriving inst_infos extra_binds repMetaTys repFamInsts
= hang (ptext (sLit "Derived instances:"))
@@ -370,12 +369,11 @@ tcDeriving tycl_decls inst_decls deriv_decls
hangP s x = text "" $$ hang (ptext (sLit s)) 2 x
-- Prints the representable type family instance
-pprRepTy :: FamInst Unbranched -> SDoc
-pprRepTy fi@(FamInst { fi_branches = FirstBranch (FamInstBranch { fib_lhs = lhs
- , fib_rhs = rhs }) })
+pprRepTy :: FamInst -> SDoc
+pprRepTy fi@(FamInst { fi_tys = lhs })
= ptext (sLit "type") <+> ppr (mkTyConApp (famInstTyCon fi) lhs) <+>
- equals <+> ppr rhs
-
+ equals <+> ppr rhs
+ where rhs = famInstRHS fi
-- As of 24 April 2012, this only shares MetaTyCons between derivations of
-- Generic and Generic1; thus the types and logic are quite simple.
@@ -552,8 +550,9 @@ deriveFamInst decl@(DataFamInstDecl { dfid_tycon = L _ tc_name, dfid_pats = pats
, dfid_defn = HsDataDefn { dd_derivs = Just preds } })
= tcAddDataFamInstCtxt decl $
do { fam_tc <- tcLookupTyCon tc_name
- ; tcFamTyPats fam_tc pats (\_ -> return ()) $ \ tvs' pats' _ ->
- mapM (deriveTyData tvs' fam_tc pats') preds }
+ ; tcFamTyPats tc_name (tyConKind fam_tc) pats (\_ -> return ()) $
+ \ tvs' pats' _ ->
+ mapM (deriveTyData tvs' fam_tc pats') preds }
-- Tiresomely we must figure out the "lhs", which is awkward for type families
-- E.g. data T a b = .. deriving( Eq )
-- Here, the lhs is (T a b)
@@ -744,10 +743,8 @@ mkEqnHelp orig tvs cls cls_tys tc_app mtheta
Nothing -> bale_out (ptext (sLit "No family instance for")
<+> quotes (pprTypeApp tycon tys))
Just (FamInstMatch { fim_instance = famInst
- , fim_index = index
, fim_tys = tys })
- -> ASSERT( index == 0 )
- let tycon' = dataFamInstRepTyCon famInst
+ -> let tycon' = dataFamInstRepTyCon famInst
in return (tycon', tys) }
\end{code}
diff --git a/compiler/typecheck/TcEnv.lhs b/compiler/typecheck/TcEnv.lhs
index 528c06cbd561..058e84a22e9b 100644
--- a/compiler/typecheck/TcEnv.lhs
+++ b/compiler/typecheck/TcEnv.lhs
@@ -734,8 +734,9 @@ newGlobalBinder.
newFamInstTyConName :: Located Name -> [Type] -> TcM Name
newFamInstTyConName (L loc name) tys = mk_fam_inst_name id loc name [tys]
-newFamInstAxiomName :: SrcSpan -> Name -> [[Type]] -> TcM Name
-newFamInstAxiomName = mk_fam_inst_name mkInstTyCoOcc
+newFamInstAxiomName :: SrcSpan -> Name -> [CoAxBranch] -> TcM Name
+newFamInstAxiomName loc name branches
+ = mk_fam_inst_name mkInstTyCoOcc loc name (map coAxBranchLHS branches)
mk_fam_inst_name :: (OccName -> OccName) -> SrcSpan -> Name -> [[Type]] -> TcM Name
mk_fam_inst_name adaptOcc loc tc_name tyss
diff --git a/compiler/typecheck/TcExpr.lhs b/compiler/typecheck/TcExpr.lhs
index f58c466566de..8615293a17e0 100644
--- a/compiler/typecheck/TcExpr.lhs
+++ b/compiler/typecheck/TcExpr.lhs
@@ -1238,9 +1238,8 @@ tcTagToEnum loc fun_name arg res_ty
; case mb_fam of
Nothing -> failWithTc (tagToEnumError ty doc3)
Just (FamInstMatch { fim_instance = rep_fam
- , fim_index = index
, fim_tys = rep_args })
- -> return ( mkTcSymCo (mkTcAxInstCo co_tc index rep_args)
+ -> return ( mkTcSymCo (mkTcUnbranchedAxInstCo co_tc rep_args)
, rep_tc, rep_args )
where
co_tc = famInstAxiom rep_fam
diff --git a/compiler/typecheck/TcGenDeriv.lhs b/compiler/typecheck/TcGenDeriv.lhs
index 564756269ebc..77bda8274bd3 100644
--- a/compiler/typecheck/TcGenDeriv.lhs
+++ b/compiler/typecheck/TcGenDeriv.lhs
@@ -51,7 +51,6 @@ import PrelNames hiding (error_RDR)
import PrimOp
import SrcLoc
import TyCon
-import CoAxiom
import TcType
import TysPrim
import TysWiredIn
@@ -87,7 +86,7 @@ data DerivStuff -- Please add this auxiliary stuff
-- Generics
| DerivTyCon TyCon -- New data types
- | DerivFamInst (FamInst Unbranched) -- New type family instances
+ | DerivFamInst (FamInst) -- New type family instances
-- New top-level auxiliary bindings
| DerivHsBind (LHsBind RdrName, LSig RdrName) -- Also used for SYB
@@ -1916,7 +1915,7 @@ type SeparateBagsDerivStuff = -- AuxBinds and SYB bindings
( Bag (LHsBind RdrName, LSig RdrName)
-- Extra bindings (used by Generic only)
, Bag TyCon -- Extra top-level datatypes
- , Bag (FamInst Unbranched) -- Extra family instances
+ , Bag (FamInst) -- Extra family instances
, Bag (InstInfo RdrName)) -- Extra instances
genAuxBinds :: SrcSpan -> BagDerivStuff -> SeparateBagsDerivStuff
diff --git a/compiler/typecheck/TcGenGenerics.lhs b/compiler/typecheck/TcGenGenerics.lhs
index cd233751ffdf..f4765e942546 100644
--- a/compiler/typecheck/TcGenGenerics.lhs
+++ b/compiler/typecheck/TcGenGenerics.lhs
@@ -27,9 +27,7 @@ import TcType
import TcGenDeriv
import DataCon
import TyCon
-import CoAxiom
-import Coercion ( mkSingleCoAxiom )
-import FamInstEnv ( FamInst, FamFlavor(..) )
+import FamInstEnv ( FamInst, FamFlavor(..), mkSingleCoAxiom )
import FamInst
import Module ( Module, moduleName, moduleNameString )
import IfaceEnv ( newGlobalBinder )
@@ -72,7 +70,7 @@ For the generic representation we need to generate:
\begin{code}
gen_Generic_binds :: GenericKind -> TyCon -> MetaTyCons -> Module
- -> TcM (LHsBinds RdrName, FamInst Unbranched)
+ -> TcM (LHsBinds RdrName, FamInst)
gen_Generic_binds gk tc metaTyCons mod = do
repTyInsts <- tc_mkRepFamInsts gk tc metaTyCons mod
return (mkBindsRep gk tc, repTyInsts)
@@ -404,7 +402,7 @@ tc_mkRepFamInsts :: GenericKind -- Gen0 or Gen1
-> TyCon -- The type to generate representation for
-> MetaTyCons -- Metadata datatypes to refer to
-> Module -- Used as the location of the new RepTy
- -> TcM (FamInst Unbranched) -- Generated representation0 coercion
+ -> TcM (FamInst) -- Generated representation0 coercion
tc_mkRepFamInsts gk tycon metaDts mod =
-- Consider the example input tycon `D`, where data D a b = D_ a
-- Also consider `R:DInt`, where { data family D x y :: * -> *
@@ -445,7 +443,7 @@ tc_mkRepFamInsts gk tycon metaDts mod =
(nameSrcSpan (tyConName tycon))
; let axiom = mkSingleCoAxiom rep_name tyvars fam_tc appT repTy
- ; newFamInst SynFamilyInst False axiom }
+ ; newFamInst SynFamilyInst axiom }
--------------------------------------------------------------------------------
-- Type representation
diff --git a/compiler/typecheck/TcHsType.lhs b/compiler/typecheck/TcHsType.lhs
index d810b0a2f868..c7d65a6b57fe 100644
--- a/compiler/typecheck/TcHsType.lhs
+++ b/compiler/typecheck/TcHsType.lhs
@@ -18,7 +18,7 @@ module TcHsType (
UserTypeCtxt(..),
-- Type checking type and class decls
- kcTyClTyVars, tcTyClTyVars,
+ kcLookupKind, kcTyClTyVars, tcTyClTyVars,
tcHsConArgType, tcDataKindSig,
tcClassSigType,
diff --git a/compiler/typecheck/TcInstDcls.lhs b/compiler/typecheck/TcInstDcls.lhs
index 753bc327beb4..2156bba9dbeb 100644
--- a/compiler/typecheck/TcInstDcls.lhs
+++ b/compiler/typecheck/TcInstDcls.lhs
@@ -31,7 +31,6 @@ import TcRnMonad
import TcValidity
import TcMType
import TcType
-import Coercion( mkSingleCoAxiom, mkBranchedCoAxiom, pprCoAxBranch )
import BuildTyCl
import Inst
import InstEnv
@@ -455,7 +454,7 @@ addClsInsts :: [InstInfo Name] -> TcM a -> TcM a
addClsInsts infos thing_inside
= tcExtendLocalInstEnv (map iSpec infos) thing_inside
-addFamInsts :: [FamInst Branched] -> TcM a -> TcM a
+addFamInsts :: [FamInst] -> TcM a -> TcM a
-- Extend (a) the family instance envt
-- (b) the type envt with stuff from data type decls
addFamInsts fam_insts thing_inside
@@ -465,7 +464,7 @@ addFamInsts fam_insts thing_inside
; tcg_env <- tcAddImplicits things
; setGblEnv tcg_env thing_inside }
where
- axioms = map famInstAxiom fam_insts
+ axioms = map (toBranchedAxiom . famInstAxiom) fam_insts
tycons = famInstsRepTyCons fam_insts
things = map ATyCon tycons ++ map ACoAxiom axioms
\end{code}
@@ -489,7 +488,7 @@ the brutal solution will do.
\begin{code}
tcLocalInstDecl :: LInstDecl Name
- -> TcM ([InstInfo Name], [FamInst Branched])
+ -> TcM ([InstInfo Name], [FamInst])
-- A source-file instance declaration
-- Type-check all the stuff before the "where"
--
@@ -500,13 +499,13 @@ tcLocalInstDecl (L loc (TyFamInstD { tfid_inst = decl }))
tcLocalInstDecl (L loc (DataFamInstD { dfid_inst = decl }))
= do { fam_inst <- tcDataFamInstDecl Nothing (L loc decl)
- ; return ([], [toBranchedFamInst fam_inst]) }
+ ; return ([], [fam_inst]) }
tcLocalInstDecl (L loc (ClsInstD { cid_inst = decl }))
= do { (insts, fam_insts) <- tcClsInstDecl (L loc decl)
- ; return (insts, map toBranchedFamInst fam_insts) }
+ ; return (insts, fam_insts) }
-tcClsInstDecl :: LClsInstDecl Name -> TcM ([InstInfo Name], [FamInst Unbranched])
+tcClsInstDecl :: LClsInstDecl Name -> TcM ([InstInfo Name], [FamInst])
tcClsInstDecl (L loc (ClsInstDecl { cid_poly_ty = poly_ty, cid_binds = binds
, cid_sigs = uprags, cid_tyfam_insts = ats
, cid_datafam_insts = adts }))
@@ -533,7 +532,7 @@ tcClsInstDecl (L loc (ClsInstDecl { cid_poly_ty = poly_ty, cid_binds = binds
; let defined_ats = mkNameSet $ map (tyFamInstDeclName . unLoc) ats
defined_adts = mkNameSet $ map (unLoc . dfid_tycon . unLoc) adts
- mk_deflt_at_instances :: ClassATItem -> TcM [FamInst Unbranched]
+ mk_deflt_at_instances :: ClassATItem -> TcM [FamInst]
mk_deflt_at_instances (fam_tc, defs)
-- User supplied instances ==> everything is OK
| tyConName fam_tc `elemNameSet` defined_ats
@@ -558,7 +557,7 @@ tcClsInstDecl (L loc (ClsInstDecl { cid_poly_ty = poly_ty, cid_binds = binds
; rep_tc_name <- newFamInstTyConName (noLoc (tyConName fam_tc)) pat_tys'
; let axiom = mkSingleCoAxiom rep_tc_name tvs' fam_tc pat_tys' rhs'
; ASSERT( tyVarsOfType rhs' `subVarSet` tv_set' )
- newFamInst SynFamilyInst False {- group -} axiom }
+ newFamInst SynFamilyInst axiom }
; tyfam_insts1 <- mapM mk_deflt_at_instances (classATItems clas)
@@ -581,10 +580,10 @@ tcClsInstDecl (L loc (ClsInstDecl { cid_poly_ty = poly_ty, cid_binds = binds
tcAssocTyDecl :: Class -- Class of associated type
-> VarEnv Type -- Instantiation of class TyVars
-> LTyFamInstDecl Name
- -> TcM (FamInst Unbranched)
+ -> TcM (FamInst)
tcAssocTyDecl clas mini_env ldecl
= do { fam_inst <- tcTyFamInstDecl (Just (clas, mini_env)) ldecl
- ; return $ toUnbranchedFamInst fam_inst }
+ ; return fam_inst }
\end{code}
%************************************************************************
@@ -620,14 +619,12 @@ tcFamInstDeclCombined mb_clsinfo fam_tc_lname
; return fam_tc }
tcTyFamInstDecl :: Maybe (Class, VarEnv Type) -- the class & mini_env if applicable
- -> LTyFamInstDecl Name -> TcM (FamInst Branched)
+ -> LTyFamInstDecl Name -> TcM FamInst
-- "type instance"
-tcTyFamInstDecl mb_clsinfo (L loc decl@(TyFamInstDecl { tfid_group = group
- , tfid_eqns = eqns }))
+tcTyFamInstDecl mb_clsinfo (L loc decl@(TyFamInstDecl { tfid_eqn = eqn }))
= setSrcSpan loc $
tcAddTyFamInstCtxt decl $
- do { let (eqn1:_) = eqns
- fam_lname = tfie_tycon (unLoc eqn1)
+ do { let fam_lname = tfie_tycon (unLoc eqn)
; fam_tc <- tcFamInstDeclCombined mb_clsinfo fam_lname
-- (0) Check it's an open type family
@@ -637,36 +634,20 @@ tcTyFamInstDecl mb_clsinfo (L loc decl@(TyFamInstDecl { tfid_group = group
(notOpenFamily fam_tc)
-- (1) do the work of verifying the synonym group
- ; co_ax_branches <- tcSynFamInstDecl fam_tc decl
+ ; co_ax_branch <- tcSynFamInstDecl fam_tc decl
- -- (2) check for validity and inaccessibility
- ; foldlM_ (check_valid_branch fam_tc) [] co_ax_branches
+ -- (2) check for validity
+ ; checkValidTyFamInst mb_clsinfo fam_tc co_ax_branch
-- (3) construct coercion axiom
; rep_tc_name <- newFamInstAxiomName loc
(tyFamInstDeclName decl)
- (map cab_lhs co_ax_branches)
- ; let axiom = mkBranchedCoAxiom rep_tc_name fam_tc co_ax_branches
- ; newFamInst SynFamilyInst group axiom }
- where
- check_valid_branch :: TyCon
- -> [CoAxBranch] -- previous
- -> CoAxBranch -- current
- -> TcM [CoAxBranch] -- current : previous
- check_valid_branch fam_tc prev_branches cur_branch
- = do { -- Check the well-formedness of the instance
- checkValidTyFamInst mb_clsinfo fam_tc cur_branch
-
- -- Check whether the branch is dominated by earlier
- -- ones and hence is inaccessible
- ; when (cur_branch `isDominatedBy` prev_branches) $
- setSrcSpan (coAxBranchSpan cur_branch) $
- addErrTc $ inaccessibleCoAxBranch fam_tc cur_branch
-
- ; return $ cur_branch : prev_branches }
+ [co_ax_branch]
+ ; let axiom = mkUnbranchedCoAxiom rep_tc_name fam_tc co_ax_branch
+ ; newFamInst SynFamilyInst axiom }
tcDataFamInstDecl :: Maybe (Class, VarEnv Type)
- -> LDataFamInstDecl Name -> TcM (FamInst Unbranched)
+ -> LDataFamInstDecl Name -> TcM FamInst
-- "newtype instance" and "data instance"
tcDataFamInstDecl mb_clsinfo
(L loc decl@(DataFamInstDecl
@@ -683,7 +664,7 @@ tcDataFamInstDecl mb_clsinfo
; checkTc (isAlgTyCon fam_tc) (wrongKindOfFamily fam_tc)
-- Kind check type patterns
- ; tcFamTyPats fam_tc pats (kcDataDefn defn) $
+ ; tcFamTyPats (unLoc fam_tc_name) (tyConKind fam_tc) pats (kcDataDefn defn) $
\tvs' pats' res_kind -> do
{ -- Check that left-hand side contains no type family applications
@@ -725,7 +706,7 @@ tcDataFamInstDecl mb_clsinfo
-- further instance might not introduce a new recursive
-- dependency. (2) They are always valid loop breakers as
-- they involve a coercion.
- ; fam_inst <- newFamInst (DataFamilyInst rep_tc) False axiom
+ ; fam_inst <- newFamInst (DataFamilyInst rep_tc) axiom
; return (rep_tc, fam_inst) }
-- Remember to check validity; no recursion to worry about here
@@ -765,6 +746,8 @@ Solution: eta-reduce both axioms, thus:
Now
d' = d |> Monad (sym (ax2 ; ax1))
+This eta reduction happens both for data instances and newtype instances.
+
See Note [Newtype eta] in TyCon.
@@ -1576,11 +1559,6 @@ badFamInstDecl tc_name
quotes (ppr tc_name)
, nest 2 (parens $ ptext (sLit "Use -XTypeFamilies to allow indexed type families")) ]
-inaccessibleCoAxBranch :: TyCon -> CoAxBranch -> SDoc
-inaccessibleCoAxBranch tc fi
- = ptext (sLit "Inaccessible family instance equation:") $$
- (pprCoAxBranch tc fi)
-
notOpenFamily :: TyCon -> SDoc
notOpenFamily tc
= ptext (sLit "Illegal instance for closed family") <+> quotes (ppr tc)
diff --git a/compiler/typecheck/TcInteract.lhs b/compiler/typecheck/TcInteract.lhs
index 42238a8769ce..27cf52e85e79 100644
--- a/compiler/typecheck/TcInteract.lhs
+++ b/compiler/typecheck/TcInteract.lhs
@@ -20,7 +20,6 @@ import VarSet
import Type
import Unify
import FamInstEnv
-import Coercion( mkAxInstRHS )
import Var
import TcType
@@ -1431,17 +1430,13 @@ doTopReactFunEq _ct fl fun_tc args xi loc
do { match_res <- matchFam fun_tc args -- See Note [MATCHING-SYNONYMS]
; case match_res of {
Nothing -> return NoTopInt ;
- Just (FamInstMatch { fim_instance = famInst
- , fim_index = index
- , fim_tys = rep_tys }) ->
+ Just (co, ty) ->
-- Found a top-level instance
do { -- Add it to the solved goals
unless (isDerived fl) (addSolvedFunEq fam_ty fl xi)
- ; let coe_ax = famInstAxiom famInst
- ; succeed_with "Fun/Top" (mkTcAxInstCo coe_ax index rep_tys)
- (mkAxInstRHS coe_ax index rep_tys) } } } } }
+ ; succeed_with "Fun/Top" co ty } } } } }
where
fam_ty = mkTyConApp fun_tc args
@@ -1709,17 +1704,17 @@ matchClassInst _ clas [ k, ty ] _
case unwrapNewTyCon_maybe (classTyCon clas) of
Just (_,dictRep, axDict)
| Just tcSing <- tyConAppTyCon_maybe dictRep ->
- do mbInst <- matchFam tcSing [k,ty]
+ do mbInst <- matchOpenFam tcSing [k,ty]
case mbInst of
Just FamInstMatch
{ fim_instance = FamInst { fi_axiom = axDataFam
, fi_flavor = DataFamilyInst tcon
}
- , fim_index = ix, fim_tys = tys
+ , fim_tys = tys
} | Just (_,_,axSing) <- unwrapNewTyCon_maybe tcon ->
do let co1 = mkTcSymCo $ mkTcUnbranchedAxInstCo axSing tys
- co2 = mkTcSymCo $ mkTcAxInstCo axDataFam ix tys
+ co2 = mkTcSymCo $ mkTcUnbranchedAxInstCo axDataFam tys
co3 = mkTcSymCo $ mkTcUnbranchedAxInstCo axDict [k,ty]
return $ GenInst [] $ EvCast (EvLit evLit) $
mkTcTransCo co1 $ mkTcTransCo co2 co3
diff --git a/compiler/typecheck/TcRnDriver.lhs b/compiler/typecheck/TcRnDriver.lhs
index 08590203a3af..56cdf60afc75 100644
--- a/compiler/typecheck/TcRnDriver.lhs
+++ b/compiler/typecheck/TcRnDriver.lhs
@@ -460,6 +460,7 @@ tcRnSrcDecls boot_iface decls
tcg_fords = fords' } } ;
setGlobalTypeEnv tcg_env' final_type_env
+
} }
tc_rn_src_decls :: ModDetails
@@ -487,7 +488,7 @@ tc_rn_src_decls boot_details ds
case group_tail of {
Nothing -> do { tcg_env <- checkMain ; -- Check for `main'
traceTc "returning from tc_rn_src_decls: " $
- ppr $ nameEnvElts $ tcg_type_env tcg_env ; -- RAE
+ ppr $ nameEnvElts $ tcg_type_env tcg_env ;
return (tcg_env, tcl_env)
} ;
@@ -769,8 +770,9 @@ checkBootTyCon tc1 tc2
, Just syn_rhs2 <- synTyConRhs_maybe tc2
, Just env <- eqTyVarBndrs emptyRnEnv2 (tyConTyVars tc1) (tyConTyVars tc2)
= ASSERT(tc1 == tc2)
- let eqSynRhs (SynFamilyTyCon o1 i1) (SynFamilyTyCon o2 i2)
- = o1==o2 && i1==i2
+ let eqSynRhs OpenSynFamilyTyCon OpenSynFamilyTyCon = True
+ eqSynRhs (ClosedSynFamilyTyCon ax1) (ClosedSynFamilyTyCon ax2)
+ = ax1 == ax2
eqSynRhs (SynonymTyCon t1) (SynonymTyCon t2)
= eqTypeX env t1 t2
eqSynRhs _ _ = False
@@ -956,7 +958,6 @@ tcTopSrcDecls boot_details
-- tcg_dus: see Note [Newtype constructor usage in foreign declarations]
addUsedRdrNames fo_rdr_names ;
- traceTc "Tc8: type_env: " (ppr $ nameEnvElts $ tcg_type_env tcg_env') ; -- RAE
return (tcg_env', tcl_env)
}}}}}}
where
@@ -1654,13 +1655,8 @@ tcRnDeclsi hsc_env ictxt local_decls =
tcg_vects = vects',
tcg_fords = fords' }
- tcg_env'' <- setGlobalTypeEnv tcg_env' final_type_env
-
- traceTc "returning from tcRnDeclsi: " $ ppr $ nameEnvElts $ tcg_type_env tcg_env'' -- RAE
-
- return tcg_env''
-
-
+ setGlobalTypeEnv tcg_env' final_type_env
+
#endif /* GHCi */
\end{code}
@@ -1738,7 +1734,7 @@ tcRnLookupName' name = do
tcRnGetInfo :: HscEnv
-> Name
- -> IO (Messages, Maybe (TyThing, Fixity, [ClsInst], [FamInst Branched]))
+ -> IO (Messages, Maybe (TyThing, Fixity, [ClsInst], [FamInst]))
-- Used to implement :info in GHCi
--
@@ -1763,13 +1759,13 @@ tcRnGetInfo hsc_env name
(cls_insts, fam_insts) <- lookupInsts thing
return (thing, fixity, cls_insts, fam_insts)
-lookupInsts :: TyThing -> TcM ([ClsInst],[FamInst Branched])
+lookupInsts :: TyThing -> TcM ([ClsInst],[FamInst])
lookupInsts (ATyCon tc)
| Just cls <- tyConClass_maybe tc
= do { inst_envs <- tcGetInstEnvs
; return (classInstances inst_envs cls, []) }
- | isFamilyTyCon tc || isTyConAssoc tc
+ | isOpenFamilyTyCon tc || isTyConAssoc tc
= do { inst_envs <- tcGetFamInstEnvs
; return ([], familyInstances inst_envs tc) }
@@ -1901,7 +1897,7 @@ ppr_types insts type_env
-- that the type checker has invented. Top-level user-defined things
-- have External names.
-ppr_tycons :: [FamInst br] -> TypeEnv -> SDoc
+ppr_tycons :: [FamInst] -> TypeEnv -> SDoc
ppr_tycons fam_insts type_env
= vcat [ text "TYPE CONSTRUCTORS"
, nest 2 (ppr_tydecls tycons)
@@ -1919,7 +1915,7 @@ ppr_insts :: [ClsInst] -> SDoc
ppr_insts [] = empty
ppr_insts ispecs = text "INSTANCES" $$ nest 2 (pprInstances ispecs)
-ppr_fam_insts :: [FamInst br] -> SDoc
+ppr_fam_insts :: [FamInst] -> SDoc
ppr_fam_insts [] = empty
ppr_fam_insts fam_insts =
text "FAMILY INSTANCES" $$ nest 2 (pprFamInsts fam_insts)
diff --git a/compiler/typecheck/TcRnTypes.lhs b/compiler/typecheck/TcRnTypes.lhs
index b53c40d3581d..43b4f36aa20c 100644
--- a/compiler/typecheck/TcRnTypes.lhs
+++ b/compiler/typecheck/TcRnTypes.lhs
@@ -298,7 +298,7 @@ data TcGblEnv
tcg_anns :: [Annotation], -- ...Annotations
tcg_tcs :: [TyCon], -- ...TyCons and Classes
tcg_insts :: [ClsInst], -- ...Instances
- tcg_fam_insts :: [FamInst Branched],-- ...Family instances
+ tcg_fam_insts :: [FamInst], -- ...Family instances
tcg_rules :: [LRuleDecl Id], -- ...Rules
tcg_fords :: [LForeignDecl Id], -- ...Foreign import & exports
tcg_vects :: [LVectDecl Id], -- ...Vectorisation declarations
diff --git a/compiler/typecheck/TcSMonad.lhs b/compiler/typecheck/TcSMonad.lhs
index 930444a1bae8..9a7049fccaef 100644
--- a/compiler/typecheck/TcSMonad.lhs
+++ b/compiler/typecheck/TcSMonad.lhs
@@ -86,7 +86,7 @@ module TcSMonad (
getDefaultInfo, getDynFlags,
- matchClass, matchFam, MatchInstResult (..),
+ matchClass, matchFam, matchOpenFam, MatchInstResult (..),
checkWellStagedDFun,
pprEq -- Smaller utils, re-exported from TcM
-- TODO (DV): these are only really used in the
@@ -132,6 +132,7 @@ import TcRnTypes
import Unique
import UniqFM
import Maybes ( orElse, catMaybes, firstJust )
+import Pair ( pSnd )
import Control.Monad( unless, when, zipWithM )
import Data.IORef
@@ -1674,8 +1675,30 @@ matchClass clas tys
}
}
-matchFam :: TyCon -> [Type] -> TcS (Maybe FamInstMatch)
-matchFam tycon args = wrapTcS $ tcLookupFamInst tycon args
+matchOpenFam :: TyCon -> [Type] -> TcS (Maybe FamInstMatch)
+matchOpenFam tycon args = wrapTcS $ tcLookupFamInst tycon args
+
+matchFam :: TyCon -> [Type] -> TcS (Maybe (TcCoercion, TcType))
+matchFam tycon args
+ | isOpenSynFamilyTyCon tycon
+ = do { maybe_match <- matchOpenFam tycon args
+ ; case maybe_match of
+ Nothing -> return Nothing
+ Just (FamInstMatch { fim_instance = famInst
+ , fim_tys = inst_tys })
+ -> let co = mkTcUnbranchedAxInstCo (famInstAxiom famInst) inst_tys
+ ty = pSnd $ tcCoercionKind co
+ in return $ Just (co, ty) }
+
+ | Just ax <- isClosedSynFamilyTyCon_maybe tycon
+ , Just (ind, inst_tys) <- chooseBranch ax args
+ = let co = mkTcAxInstCo ax ind inst_tys
+ ty = pSnd (tcCoercionKind co)
+ in return $ Just (co, ty)
+
+ | otherwise
+ = return Nothing
+
\end{code}
\begin{code}
diff --git a/compiler/typecheck/TcSplice.lhs b/compiler/typecheck/TcSplice.lhs
index 2561bd967c5f..59b06d4a8eee 100644
--- a/compiler/typecheck/TcSplice.lhs
+++ b/compiler/typecheck/TcSplice.lhs
@@ -1027,7 +1027,7 @@ reifyInstances th_nm th_tys
-> do { inst_envs <- tcGetInstEnvs
; let (matches, unifies, _) = lookupInstEnv inst_envs cls tys
; mapM reifyClassInstance (map fst matches ++ unifies) }
- | isFamilyTyCon tc
+ | isOpenFamilyTyCon tc
-> do { inst_envs <- tcGetFamInstEnvs
; let matches = lookupFamInstEnv inst_envs tc tys
; mapM (reifyFamilyInstance . fim_instance) matches }
@@ -1169,7 +1169,6 @@ reifyThing (AGlobal (AnId id))
}
reifyThing (AGlobal (ATyCon tc)) = reifyTyCon tc
-reifyThing (AGlobal (ACoAxiom ax)) = reifyAxiom ax
reifyThing (AGlobal (ADataCon dc))
= do { let name = dataConName dc
; ty <- reifyType (idType (dataConWrapId dc))
@@ -1192,12 +1191,7 @@ reifyThing (ATyVar tv tv1)
reifyThing thing = pprPanic "reifyThing" (pprTcTyThingCategory thing)
-------------------------------
-reifyAxiom :: CoAxiom br -> TcM TH.Info
-reifyAxiom (CoAxiom { co_ax_tc = tc, co_ax_branches = branches })
- = do { eqns <- sequence $ brListMap reifyAxBranch branches
- ; return (TH.TyConI (TH.TySynInstD (reifyName tc) eqns)) }
-
+-------------------------------------------
reifyAxBranch :: CoAxBranch -> TcM TH.TySynEqn
reifyAxBranch (CoAxBranch { cab_lhs = args, cab_rhs = rhs })
= do { args' <- mapM reifyType args
@@ -1216,18 +1210,24 @@ reifyTyCon tc
= return (TH.PrimTyConI (reifyName tc) (tyConArity tc) (isUnLiftedTyCon tc))
| isFamilyTyCon tc
- = do { let flavour = reifyFamFlavour tc
- tvs = tyConTyVars tc
+ = do { let tvs = tyConTyVars tc
kind = tyConKind tc
; kind' <- if isLiftedTypeKind kind then return Nothing
else fmap Just (reifyKind kind)
- ; fam_envs <- tcGetFamInstEnvs
- ; instances <- mapM reifyFamilyInstance (familyInstances fam_envs tc)
; tvs' <- reifyTyVars tvs
- ; return (TH.FamilyI
- (TH.FamilyD flavour (reifyName tc) tvs' kind')
- instances) }
+ ; flav' <- reifyFamFlavour tc
+ ; case flav' of
+ { Left flav -> -- open type/data family
+ do { fam_envs <- tcGetFamInstEnvs
+ ; instances <- mapM reifyFamilyInstance (familyInstances fam_envs tc)
+ ; return (TH.FamilyI
+ (TH.FamilyD flav (reifyName tc) tvs' kind')
+ instances) }
+ ; Right eqns -> -- closed type family
+ return (TH.FamilyI
+ (TH.ClosedTypeFamilyD (reifyName tc) tvs' kind' eqns)
+ []) } }
| Just (tvs, rhs) <- synTyConDefn_maybe tc -- Vanilla type synonym
= do { rhs' <- reifyType rhs
@@ -1308,31 +1308,26 @@ reifyClassInstance i
n_silent = dfunNSilent dfun
------------------------------
-reifyFamilyInstance :: FamInst br -> TcM TH.Dec
-reifyFamilyInstance fi@(FamInst { fi_flavor = flavor
- , fi_branches = branches
- , fi_fam = fam })
+reifyFamilyInstance :: FamInst -> TcM TH.Dec
+reifyFamilyInstance (FamInst { fi_flavor = flavor
+ , fi_fam = fam
+ , fi_tys = lhs
+ , fi_rhs = rhs })
= case flavor of
SynFamilyInst ->
- do { th_eqns <- sequence $ brListMap reifyFamInstBranch branches
- ; return (TH.TySynInstD (reifyName fam) th_eqns) }
+ do { th_lhs <- reifyTypes lhs
+ ; th_rhs <- reifyType rhs
+ ; return (TH.TySynInstD (reifyName fam) (TH.TySynEqn th_lhs th_rhs)) }
DataFamilyInst rep_tc ->
do { let tvs = tyConTyVars rep_tc
fam' = reifyName fam
- lhs = famInstBranchLHS $ famInstSingleBranch (toUnbranchedFamInst fi)
; cons <- mapM (reifyDataCon (mkTyVarTys tvs)) (tyConDataCons rep_tc)
; th_tys <- reifyTypes lhs
; return (if isNewTyCon rep_tc
then TH.NewtypeInstD [] fam' th_tys (head cons) []
else TH.DataInstD [] fam' th_tys cons []) }
-reifyFamInstBranch :: FamInstBranch -> TcM TH.TySynEqn
-reifyFamInstBranch (FamInstBranch { fib_lhs = lhs, fib_rhs = rhs })
- = do { th_lhs <- reifyTypes lhs
- ; th_rhs <- reifyType rhs
- ; return (TH.TySynEqn th_lhs th_rhs) }
-
------------------------------
reifyType :: TypeRep.Type -> TcM TH.Type
-- Monadic only because of failure
@@ -1394,11 +1389,17 @@ reifyCxt = mapM reifyPred
reifyFunDep :: ([TyVar], [TyVar]) -> TH.FunDep
reifyFunDep (xs, ys) = TH.FunDep (map reifyName xs) (map reifyName ys)
-reifyFamFlavour :: TyCon -> TH.FamFlavour
-reifyFamFlavour tc | isSynFamilyTyCon tc = TH.TypeFam
- | isFamilyTyCon tc = TH.DataFam
- | otherwise
- = panic "TcSplice.reifyFamFlavour: not a type family"
+reifyFamFlavour :: TyCon -> TcM (Either TH.FamFlavour [TH.TySynEqn])
+reifyFamFlavour tc
+ | isOpenSynFamilyTyCon tc = return $ Left TH.TypeFam
+ | isDataFamilyTyCon tc = return $ Left TH.DataFam
+
+ | Just ax <- isClosedSynFamilyTyCon_maybe tc
+ = do { eqns <- brListMapM reifyAxBranch $ coAxiomBranches ax
+ ; return $ Right eqns }
+
+ | otherwise
+ = panic "TcSplice.reifyFamFlavour: not a type family"
reifyTyVars :: [TyVar] -> TcM [TH.TyVarBndr]
reifyTyVars = mapM reifyTyVar . filter isTypeVar
diff --git a/compiler/typecheck/TcTyClsDecls.lhs b/compiler/typecheck/TcTyClsDecls.lhs
index 41cbeae34999..044086d93785 100644
--- a/compiler/typecheck/TcTyClsDecls.lhs
+++ b/compiler/typecheck/TcTyClsDecls.lhs
@@ -37,11 +37,12 @@ import TcMType
import TcType
import TysWiredIn( unitTy )
import FamInst
-import Coercion( mkCoAxBranch )
+import FamInstEnv( isDominatedBy, mkCoAxBranch, mkBranchedCoAxiom )
+import Coercion( pprCoAxBranch )
import Type
import Kind
import Class
-import CoAxiom( CoAxBranch(..) )
+import CoAxiom
import TyCon
import DataCon
import Id
@@ -648,16 +649,53 @@ tcTyClDecl1 _ _
\begin{code}
tcFamDecl1 :: TyConParent -> FamilyDecl Name -> TcM [TyThing]
tcFamDecl1 parent
- (FamilyDecl {fdFlavour = TypeFamily, fdLName = L _ tc_name, fdTyVars = tvs})
+ (FamilyDecl {fdInfo = OpenTypeFamily, fdLName = L _ tc_name, fdTyVars = tvs})
= tcTyClTyVars tc_name tvs $ \ tvs' kind -> do
- { traceTc "type family:" (ppr tc_name)
+ { traceTc "open type family:" (ppr tc_name)
; checkFamFlag tc_name
- ; let syn_rhs = SynFamilyTyCon { synf_open = True, synf_injective = False }
- ; tycon <- buildSynTyCon tc_name tvs' syn_rhs kind parent
+ ; tycon <- buildSynTyCon tc_name tvs' OpenSynFamilyTyCon kind parent
; return [ATyCon tycon] }
tcFamDecl1 parent
- (FamilyDecl {fdFlavour = DataFamily, fdLName = L _ tc_name, fdTyVars = tvs})
+ (FamilyDecl { fdInfo = ClosedTypeFamily eqns
+ , fdLName = lname@(L _ tc_name), fdTyVars = tvs })
+-- Closed type families are a little tricky, because they contain the definition
+-- of both the type family and the equations for a CoAxiom.
+ = do { traceTc "closed type family:" (ppr tc_name)
+ -- the variables in the header have no scope:
+ ; (tvs', kind) <- tcTyClTyVars tc_name tvs $ \ tvs' kind ->
+ return (tvs', kind)
+
+ ; checkFamFlag tc_name -- make sure we have -XTypeFamilies
+
+ -- check to make sure all the names used in the equations are
+ -- consistent
+ ; let names = map (tfie_tycon . unLoc) eqns
+ ; tcSynFamInstNames lname names
+
+ -- process the equations, creating CoAxBranches
+ ; tycon_kind <- kcLookupKind tc_name
+ ; branches <- mapM (tcTyFamInstEqn tc_name tycon_kind) eqns
+
+ -- we need the tycon that we will be creating, but it's in scope.
+ -- just look it up.
+ ; fam_tc <- tcLookupLocatedTyCon lname
+
+ -- create a CoAxiom, with the correct src location
+ ; loc <- getSrcSpanM
+ ; co_ax_name <- newFamInstAxiomName loc tc_name branches
+ ; let co_ax = mkBranchedCoAxiom co_ax_name fam_tc branches
+
+ -- now, finally, build the TyCon
+ ; let syn_rhs = ClosedSynFamilyTyCon co_ax
+ ; tycon <- buildSynTyCon tc_name tvs' syn_rhs kind parent
+
+ ; return [ATyCon tycon, ACoAxiom co_ax] }
+-- We check for instance validity later, when doing validity checking for
+-- the tycon
+
+tcFamDecl1 parent
+ (FamilyDecl {fdInfo = DataFamily, fdLName = L _ tc_name, fdTyVars = tvs})
= tcTyClTyVars tc_name tvs $ \ tvs' kind -> do
{ traceTc "data family:" (ppr tc_name)
; checkFamFlag tc_name
@@ -770,13 +808,13 @@ tcClassATs class_name parent ats at_defs
tc_at at = do { [ATyCon fam_tc] <- addLocM (tcFamDecl1 parent) at
; let at_defs = lookupNameEnv at_defs_map (unLoc $ fdLName $ unLoc at)
`orElse` []
- ; atd <- concatMapM (tcDefaultAssocDecl fam_tc) at_defs
+ ; atd <- mapM (tcDefaultAssocDecl fam_tc) at_defs
; return (fam_tc, atd) }
-------------------------
tcDefaultAssocDecl :: TyCon -- ^ Family TyCon
-> LTyFamInstDecl Name -- ^ RHS
- -> TcM [CoAxBranch] -- ^ Type checked RHS and free TyVars
+ -> TcM CoAxBranch -- ^ Type checked RHS and free TyVars
tcDefaultAssocDecl fam_tc (L loc decl)
= setSrcSpan loc $
tcAddTyFamInstCtxt decl $
@@ -785,17 +823,12 @@ tcDefaultAssocDecl fam_tc (L loc decl)
-- We check for well-formedness and validity later, in checkValidClass
-------------------------
-tcSynFamInstDecl :: TyCon -> TyFamInstDecl Name -> TcM [CoAxBranch]
+tcSynFamInstDecl :: TyCon -> TyFamInstDecl Name -> TcM CoAxBranch
-- Placed here because type family instances appear as
-- default decls in class declarations
-tcSynFamInstDecl fam_tc (TyFamInstDecl { tfid_eqns = eqns })
- -- we know the first equation matches the fam_tc because of the lookup logic
- -- now, just check that all other names match the first
- = do { let names = map (tfie_tycon . unLoc) eqns
- first = head names
- ; tcSynFamInstNames first names
- ; checkTc (isSynTyCon fam_tc) (wrongKindOfFamily fam_tc)
- ; mapM (tcTyFamInstEqn fam_tc) eqns }
+tcSynFamInstDecl fam_tc (TyFamInstDecl { tfid_eqn = eqn })
+ = do { checkTc (isSynTyCon fam_tc) (wrongKindOfFamily fam_tc)
+ ; tcTyFamInstEqn (tyConName fam_tc) (tyConKind fam_tc) eqn }
-- Checks to make sure that all the names in an instance group are the same
tcSynFamInstNames :: Located Name -> [Located Name] -> TcM ()
@@ -808,15 +841,15 @@ tcSynFamInstNames (L _ first) names
= setSrcSpan loc $
failWithTc (msg_fun name)
-tcTyFamInstEqn :: TyCon -> LTyFamInstEqn Name -> TcM CoAxBranch
-tcTyFamInstEqn fam_tc
+tcTyFamInstEqn :: Name -> Kind -> LTyFamInstEqn Name -> TcM CoAxBranch
+tcTyFamInstEqn fam_tc_name kind
(L loc (TyFamInstEqn { tfie_pats = pats, tfie_rhs = hs_ty }))
= setSrcSpan loc $
- tcFamTyPats fam_tc pats (discardResult . (tcCheckLHsType hs_ty)) $
+ tcFamTyPats fam_tc_name kind pats (discardResult . (tcCheckLHsType hs_ty)) $
\tvs' pats' res_kind ->
do { rhs_ty <- tcCheckLHsType hs_ty res_kind
; rhs_ty <- zonkTcTypeToType emptyZonkEnv rhs_ty
- ; traceTc "tcSynFamInstEqn" (ppr fam_tc <+> (ppr tvs' $$ ppr pats' $$ ppr rhs_ty))
+ ; traceTc "tcSynFamInstEqn" (ppr fam_tc_name <+> (ppr tvs' $$ ppr pats' $$ ppr rhs_ty))
; return (mkCoAxBranch tvs' pats' rhs_ty loc) }
kcDataDefn :: HsDataDefn Name -> TcKind -> TcM ()
@@ -846,7 +879,11 @@ kcResultKind (Just k) res_k
-- check is only required for type synonym instances.
-----------------
-tcFamTyPats :: TyCon
+-- Note that we can't use the family TyCon, because this is sometimes called
+-- from within a type-checking knot. So, we ask our callers to do a little more
+-- work.
+tcFamTyPats :: Name -- of the family TyCon
+ -> Kind -- of the family TyCon
-> HsWithBndrs [LHsType Name] -- Patterns
-> (TcKind -> TcM ()) -- Kind checker for RHS
-- result is ignored
@@ -863,23 +900,27 @@ tcFamTyPats :: TyCon
-- In that case, the type variable 'a' will *already be in scope*
-- (and, if C is poly-kinded, so will its kind parameter).
-tcFamTyPats fam_tc (HsWB { hswb_cts = arg_pats, hswb_kvs = kvars, hswb_tvs = tvars })
+tcFamTyPats fam_tc_name kind
+ (HsWB { hswb_cts = arg_pats, hswb_kvs = kvars, hswb_tvs = tvars })
kind_checker thing_inside
- = do { -- A family instance must have exactly the same number of type
- -- parameters as the family declaration. You can't write
- -- type family F a :: * -> *
- -- type instance F Int y = y
- -- because then the type (F Int) would be like (\y.y)
- ; let (fam_kvs, fam_body) = splitForAllTys (tyConKind fam_tc)
- fam_arity = tyConArity fam_tc - length fam_kvs
- ; checkTc (length arg_pats == fam_arity) $
- wrongNumberOfParmsErr fam_arity
+ = do { let (fam_kvs, fam_body) = splitForAllTys kind
+
+ -- We wish to check that the pattern has the right number of arguments
+ -- in checkValidFamPats (in TcValidity), so we can do the check *after*
+ -- we're done with the knot. But, the splitKindFunTysN below will panic
+ -- if there are *too many* patterns. So, we do a preliminary check here.
+ -- Note that we don't have enough information at hand to do a full check,
+ -- as that requires the full declared arity of the family, which isn't
+ -- nearby.
+ ; let max_args = length (fst $ splitKindFunTys fam_body)
+ ; checkTc (length arg_pats <= max_args) $
+ wrongNumberOfParmsErrTooMany max_args
-- Instantiate with meta kind vars
; fam_arg_kinds <- mapM (const newMetaKindVar) fam_kvs
; loc <- getSrcSpanM
; let (arg_kinds, res_kind)
- = splitKindFunTysN fam_arity $
+ = splitKindFunTysN (length arg_pats) $
substKiWith fam_kvs fam_arg_kinds fam_body
hs_tvs = HsQTvs { hsq_kvs = kvars
, hsq_tvs = userHsTyVarBndrs loc tvars }
@@ -888,7 +929,7 @@ tcFamTyPats fam_tc (HsWB { hswb_cts = arg_pats, hswb_kvs = kvars, hswb_tvs = tva
-- See Note [Quantifying over family patterns]
; typats <- tcHsTyVarBndrs hs_tvs $ \ _ ->
do { kind_checker res_kind
- ; tcHsArgTys (quotes (ppr fam_tc)) arg_pats arg_kinds }
+ ; tcHsArgTys (quotes (ppr fam_tc_name)) arg_pats arg_kinds }
; let all_args = fam_arg_kinds ++ typats
-- Find free variables (after zonking) and turn
@@ -1214,7 +1255,7 @@ checkValidTyCl decl
_ -> return () }
checkValidFamDecl :: FamilyDecl Name -> TcM ()
-checkValidFamDecl (FamilyDecl { fdLName = lname, fdFlavour = flav })
+checkValidFamDecl (FamilyDecl { fdLName = lname, fdInfo = flav })
= checkValidDecl (hsep [ptext (sLit "In the"), ppr flav,
ptext (sLit "declaration for"), quotes (ppr lname)])
lname
@@ -1241,8 +1282,9 @@ checkValidTyCon tc
| Just syn_rhs <- synTyConRhs_maybe tc
= case syn_rhs of
- SynFamilyTyCon {} -> return ()
- SynonymTyCon ty -> checkValidType syn_ctxt ty
+ ClosedSynFamilyTyCon ax -> checkValidClosedCoAxiom ax
+ OpenSynFamilyTyCon -> return ()
+ SynonymTyCon ty -> checkValidType syn_ctxt ty
| otherwise
= do { -- Check the context on the data decl
@@ -1306,6 +1348,23 @@ checkValidTyCon tc
fty2 = dataConFieldType con2 label
check_fields [] = panic "checkValidTyCon/check_fields []"
+checkValidClosedCoAxiom :: CoAxiom Branched -> TcM ()
+checkValidClosedCoAxiom (CoAxiom { co_ax_branches = branches, co_ax_tc = tc })
+ = tcAddClosedTypeFamilyDeclCtxt tc $
+ do { brListFoldlM_ check_accessibility [] branches
+ ; void $ brListMapM (checkValidTyFamInst Nothing tc) branches }
+ where
+ check_accessibility :: [CoAxBranch] -- prev branches (in reverse order)
+ -> CoAxBranch -- cur branch
+ -> TcM [CoAxBranch] -- cur : prev
+ -- Check whether the branch is dominated by earlier
+ -- ones and hence is inaccessible
+ check_accessibility prev_branches cur_branch
+ = do { when (cur_branch `isDominatedBy` prev_branches) $
+ setSrcSpan (coAxBranchSpan cur_branch) $
+ addErrTc $ inaccessibleCoAxBranch tc cur_branch
+ ; return (cur_branch : prev_branches) }
+
checkFieldCompat :: Name -> DataCon -> DataCon -> TyVarSet
-> Type -> Type -> Type -> Type -> TcM ()
checkFieldCompat fld con1 con2 tvs1 res1 res2 fty1 fty2
@@ -1705,10 +1764,7 @@ tcAddDefaultAssocDeclCtxt name thing_inside
tcAddTyFamInstCtxt :: TyFamInstDecl Name -> TcM a -> TcM a
tcAddTyFamInstCtxt decl
- | [_] <- tfid_eqns decl
= tcAddFamInstCtxt (ptext (sLit "type instance")) (tyFamInstDeclName decl)
- | otherwise
- = tcAddFamInstCtxt (ptext (sLit "type instance group")) (tyFamInstDeclName decl)
tcAddDataFamInstCtxt :: DataFamInstDecl Name -> TcM a -> TcM a
tcAddDataFamInstCtxt decl
@@ -1723,6 +1779,13 @@ tcAddFamInstCtxt flavour tycon thing_inside
<+> ptext (sLit "declaration for"),
quotes (ppr tycon)]
+tcAddClosedTypeFamilyDeclCtxt :: TyCon -> TcM a -> TcM a
+tcAddClosedTypeFamilyDeclCtxt tc
+ = addErrCtxt ctxt
+ where
+ ctxt = ptext (sLit "In the equations for closed type family") <+>
+ quotes (ppr tc)
+
resultTypeMisMatch :: Name -> DataCon -> DataCon -> SDoc
resultTypeMisMatch field_name con1 con2
= vcat [sep [ptext (sLit "Constructors") <+> ppr con1 <+> ptext (sLit "and") <+> ppr con2,
@@ -1830,11 +1893,6 @@ emptyConDeclsErr tycon
= sep [quotes (ppr tycon) <+> ptext (sLit "has no constructors"),
nest 2 $ ptext (sLit "(-XEmptyDataDecls permits this)")]
-wrongNumberOfParmsErr :: Arity -> SDoc
-wrongNumberOfParmsErr exp_arity
- = ptext (sLit "Number of parameters must match family declaration; expected")
- <+> ppr exp_arity
-
wrongKindOfFamily :: TyCon -> SDoc
wrongKindOfFamily family
= ptext (sLit "Wrong category of family instance; declaration was for a")
@@ -1844,10 +1902,20 @@ wrongKindOfFamily family
| isAlgTyCon family = ptext (sLit "data type")
| otherwise = pprPanic "wrongKindOfFamily" (ppr family)
+wrongNumberOfParmsErrTooMany :: Arity -> SDoc
+wrongNumberOfParmsErrTooMany max_args
+ = ptext (sLit "Number of parameters must match family declaration; expected no more than")
+ <+> ppr max_args
+
wrongNamesInInstGroup :: Name -> Name -> SDoc
wrongNamesInInstGroup first cur
- = ptext (sLit "Mismatched family names in instance group.") $$
+ = ptext (sLit "Mismatched type names in closed type family declaration.") $$
ptext (sLit "First name was") <+>
(ppr first) <> (ptext (sLit "; this one is")) <+> (ppr cur)
+inaccessibleCoAxBranch :: TyCon -> CoAxBranch -> SDoc
+inaccessibleCoAxBranch tc fi
+ = ptext (sLit "Inaccessible family instance equation:") $$
+ (pprCoAxBranch tc fi)
+
\end{code}
diff --git a/compiler/typecheck/TcValidity.lhs b/compiler/typecheck/TcValidity.lhs
index 54377192f415..968d8695ccfe 100644
--- a/compiler/typecheck/TcValidity.lhs
+++ b/compiler/typecheck/TcValidity.lhs
@@ -45,6 +45,7 @@ import ListSetOps
import SrcLoc
import Outputable
import FastString
+import BasicTypes ( Arity )
import Control.Monad
import Data.List ( (\\) )
@@ -1135,10 +1136,25 @@ checkValidFamPats :: TyCon -> [TyVar] -> [Type] -> TcM ()
-- e.g. we disallow (Trac #7536)
-- type T a = Int
-- type instance F (T a) = a
+-- c) Have the right number of patterns
checkValidFamPats fam_tc tvs ty_pats
- = do { mapM_ checkTyFamFreeness ty_pats
+ = do { -- A family instance must have exactly the same number of type
+ -- parameters as the family declaration. You can't write
+ -- type family F a :: * -> *
+ -- type instance F Int y = y
+ -- because then the type (F Int) would be like (\y.y)
+ checkTc (length ty_pats == fam_arity) $
+ wrongNumberOfParmsErr (fam_arity - length fam_kvs) -- report only types
+ ; mapM_ checkTyFamFreeness ty_pats
; let unbound_tvs = filterOut (`elemVarSet` exactTyVarsOfTypes ty_pats) tvs
; checkTc (null unbound_tvs) (famPatErr fam_tc unbound_tvs ty_pats) }
+ where fam_arity = tyConArity fam_tc
+ (fam_kvs, _) = splitForAllTys (tyConKind fam_tc)
+
+wrongNumberOfParmsErr :: Arity -> SDoc
+wrongNumberOfParmsErr exp_arity
+ = ptext (sLit "Number of parameters must match family declaration; expected")
+ <+> ppr exp_arity
-- Ensure that no type family instances occur in a type.
--
diff --git a/compiler/types/CoAxiom.lhs b/compiler/types/CoAxiom.lhs
index 365c65369fcf..7781d563564d 100644
--- a/compiler/types/CoAxiom.lhs
+++ b/compiler/types/CoAxiom.lhs
@@ -4,7 +4,7 @@
\begin{code}
-{-# LANGUAGE GADTs #-}
+{-# LANGUAGE GADTs, ScopedTypeVariables #-}
-- | Module for coercion axioms, used to represent type family instances
-- and newtypes
@@ -13,17 +13,18 @@ module CoAxiom (
Branched, Unbranched, BranchIndex, BranchList(..),
toBranchList, fromBranchList,
toBranchedList, toUnbranchedList,
- brListLength, brListNth, brListMap, brListFoldr,
- brListZipWith, brListIndices,
+ brListLength, brListNth, brListMap, brListFoldr, brListMapM,
+ brListFoldlM_, brListZipWith,
CoAxiom(..), CoAxBranch(..),
toBranchedAxiom, toUnbranchedAxiom,
coAxiomName, coAxiomArity, coAxiomBranches,
- coAxiomTyCon, isImplicitCoAxiom,
+ coAxiomTyCon, isImplicitCoAxiom, coAxiomNumPats,
coAxiomNthBranch, coAxiomSingleBranch_maybe,
coAxiomSingleBranch, coAxBranchTyVars, coAxBranchLHS,
- coAxBranchRHS, coAxBranchSpan
+ coAxBranchRHS, coAxBranchSpan, coAxBranchIncomps,
+ placeHolderIncomps
) where
import {-# SOURCE #-} TypeRep ( Type )
@@ -99,10 +100,10 @@ that code to deal with branched axioms, especially when the code can be sure
of the fact that an axiom is indeed a singleton. At the same time, it seems
dangerous to assume singlehood in various places through GHC.
-The solution to this is to label a CoAxiom (and FamInst) with a phantom
-type variable declaring whether it is known to be a singleton or not. The
-list of branches is stored using a special form of list, declared below,
-that ensures that the type variable is accurate.
+The solution to this is to label a CoAxiom with a phantom type variable
+declaring whether it is known to be a singleton or not. The list of branches
+is stored using a special form of list, declared below, that ensures that the
+type variable is accurate.
As of this writing (Dec 2012), it would not be appropriate to use a promoted
type as the phantom type, so we use empty datatypes. We wish to have GHC
@@ -154,14 +155,6 @@ brListLength :: BranchList a br -> Int
brListLength (FirstBranch _) = 1
brListLength (NextBranch _ t) = 1 + brListLength t
--- Indices
-brListIndices :: BranchList a br -> [BranchIndex]
-brListIndices bs = go 0 bs
- where
- go :: BranchIndex -> BranchList a br -> [BranchIndex]
- go n (NextBranch _ t) = n : go (n+1) t
- go n (FirstBranch {}) = [n]
-
-- lookup
brListNth :: BranchList a br -> BranchIndex -> a
brListNth (FirstBranch b) 0 = b
@@ -178,6 +171,21 @@ brListFoldr :: (a -> b -> b) -> b -> BranchList a br -> b
brListFoldr f x (FirstBranch b) = f b x
brListFoldr f x (NextBranch h t) = f h (brListFoldr f x t)
+brListMapM :: Monad m => (a -> m b) -> BranchList a br -> m [b]
+brListMapM f (FirstBranch b) = f b >>= \fb -> return [fb]
+brListMapM f (NextBranch h t) = do { fh <- f h
+ ; ft <- brListMapM f t
+ ; return (fh : ft) }
+
+brListFoldlM_ :: forall a b m br. Monad m
+ => (a -> b -> m a) -> a -> BranchList b br -> m ()
+brListFoldlM_ f z brs = do { _ <- go z brs
+ ; return () }
+ where go :: forall br'. Monad m => a -> BranchList b br' -> m a
+ go acc (FirstBranch b) = f acc b
+ go acc (NextBranch h t) = do { fh <- f acc h
+ ; go fh t }
+
-- zipWith
brListZipWith :: (a -> b -> c) -> BranchList a br1 -> BranchList b br2 -> [c]
brListZipWith f (FirstBranch a) (FirstBranch b) = [f a b]
@@ -197,6 +205,25 @@ instance Outputable a => Outputable (BranchList a br) where
%* *
%************************************************************************
+Note [Storing compatibility]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+During axiom application, we need to be aware of which branches are compatible
+with which others. The full explanation is in Note [Compatibility] in
+FamInstEnv. (The code is placed there to avoid a dependency from CoAxiom on
+the unification algorithm.) Although we could theoretically compute
+compatibility on the fly, this is silly, so we store it in a CoAxiom.
+
+Specifically, each branch refers to all other branches with which it is
+incompatible. This list might well be empty, and it will always be for the
+first branch of any axiom.
+
+CoAxBranches that do not (yet) belong to a CoAxiom should have a panic thunk
+stored in cab_incomps. The incompatibilities are properly a property of the
+axiom as a whole, and they are computed only when the final axiom is built.
+
+During serialization, the list is converted into a list of the indices
+of the branches.
+
\begin{code}
-- | A 'CoAxiom' is a \"coercion constructor\", i.e. a named equality axiom.
@@ -217,12 +244,14 @@ data CoAxiom br
data CoAxBranch
= CoAxBranch
- { cab_loc :: SrcSpan -- Location of the defining equation
- -- See Note [CoAxiom locations]
- , cab_tvs :: [TyVar] -- Bound type variables; not necessarily fresh
- -- See Note [CoAxBranch type variables]
- , cab_lhs :: [Type] -- Type patterns to match against
- , cab_rhs :: Type -- Right-hand side of the equality
+ { cab_loc :: SrcSpan -- Location of the defining equation
+ -- See Note [CoAxiom locations]
+ , cab_tvs :: [TyVar] -- Bound type variables; not necessarily fresh
+ -- See Note [CoAxBranch type variables]
+ , cab_lhs :: [Type] -- Type patterns to match against
+ , cab_rhs :: Type -- Right-hand side of the equality
+ , cab_incomps :: [CoAxBranch] -- The previous incompatible branches
+ -- See Note [Storing compatibility]
}
deriving Typeable
@@ -234,6 +263,9 @@ toUnbranchedAxiom :: CoAxiom br -> CoAxiom Unbranched
toUnbranchedAxiom (CoAxiom unique name tc branches implicit)
= CoAxiom unique name tc (toUnbranchedList branches) implicit
+coAxiomNumPats :: CoAxiom br -> Int
+coAxiomNumPats = length . coAxBranchLHS . (flip coAxiomNthBranch 0)
+
coAxiomNthBranch :: CoAxiom br -> BranchIndex -> CoAxBranch
coAxiomNthBranch (CoAxiom { co_ax_branches = bs }) index
= brListNth bs index
@@ -276,6 +308,12 @@ coAxBranchSpan = cab_loc
isImplicitCoAxiom :: CoAxiom br -> Bool
isImplicitCoAxiom = co_ax_implicit
+coAxBranchIncomps :: CoAxBranch -> [CoAxBranch]
+coAxBranchIncomps = cab_incomps
+
+placeHolderIncomps :: [CoAxBranch]
+placeHolderIncomps = panic "placeHolderIncomps"
+
\end{code}
Note [CoAxBranch type variables]
diff --git a/compiler/types/Coercion.lhs b/compiler/types/Coercion.lhs
index f30f11dce368..e1dec4938039 100644
--- a/compiler/types/Coercion.lhs
+++ b/compiler/types/Coercion.lhs
@@ -15,9 +15,6 @@
-- more on System FC and how coercions fit into it.
--
module Coercion (
- -- * CoAxioms
- mkCoAxBranch, mkBranchedCoAxiom, mkSingleCoAxiom,
-
-- * Main data type
Coercion(..), Var, CoVar,
LeftOrRight(..), pickLR,
@@ -112,58 +109,6 @@ import FastString
import qualified Data.Data as Data hiding ( TyCon )
\end{code}
-
-%************************************************************************
-%* *
- Constructing axioms
- These functions are here because tidyType etc
- are not available in CoAxiom
-%* *
-%************************************************************************
-
-Note [Tidy axioms when we build them]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-We print out axioms and don't want to print stuff like
- F k k a b = ...
-Instead we must tidy those kind variables. See Trac #7524.
-
-
-\begin{code}
-mkCoAxBranch :: [TyVar] -- original, possibly stale, tyvars
- -> [Type] -- LHS patterns
- -> Type -- RHS
- -> SrcSpan
- -> CoAxBranch
-mkCoAxBranch tvs lhs rhs loc
- = CoAxBranch { cab_tvs = tvs1
- , cab_lhs = tidyTypes env lhs
- , cab_rhs = tidyType env rhs
- , cab_loc = loc }
- where
- (env, tvs1) = tidyTyVarBndrs emptyTidyEnv tvs
- -- See Note [Tidy axioms when we build them]
-
-
-mkBranchedCoAxiom :: Name -> TyCon -> [CoAxBranch] -> CoAxiom Branched
-mkBranchedCoAxiom ax_name fam_tc branches
- = CoAxiom { co_ax_unique = nameUnique ax_name
- , co_ax_name = ax_name
- , co_ax_tc = fam_tc
- , co_ax_implicit = False
- , co_ax_branches = toBranchList branches }
-
-mkSingleCoAxiom :: Name -> [TyVar] -> TyCon -> [Type] -> Type -> CoAxiom Unbranched
-mkSingleCoAxiom ax_name tvs fam_tc lhs_tys rhs_ty
- = CoAxiom { co_ax_unique = nameUnique ax_name
- , co_ax_name = ax_name
- , co_ax_tc = fam_tc
- , co_ax_implicit = False
- , co_ax_branches = FirstBranch branch }
- where
- branch = mkCoAxBranch tvs lhs_tys rhs_ty (getSrcSpan ax_name)
-\end{code}
-
-
%************************************************************************
%* *
Coercions
@@ -673,7 +618,7 @@ mkCoVarCo cv
mkReflCo :: Type -> Coercion
mkReflCo = Refl
-mkAxInstCo :: CoAxiom br -> Int -> [Type] -> Coercion
+mkAxInstCo :: CoAxiom br -> BranchIndex -> [Type] -> Coercion
-- mkAxInstCo can legitimately be called over-staturated;
-- i.e. with more type arguments than the coercion requires
mkAxInstCo ax index tys
@@ -823,7 +768,8 @@ mkNewTypeCo name tycon tvs rhs_ty
where branch = CoAxBranch { cab_loc = getSrcSpan name
, cab_tvs = tvs
, cab_lhs = mkTyVarTys tvs
- , cab_rhs = rhs_ty }
+ , cab_rhs = rhs_ty
+ , cab_incomps = [] }
mkPiCos :: [Var] -> Coercion -> Coercion
mkPiCos vs co = foldr mkPiCo co vs
diff --git a/compiler/types/FamInstEnv.lhs b/compiler/types/FamInstEnv.lhs
index cc51568a3309..85ad7f4e19f7 100644
--- a/compiler/types/FamInstEnv.lhs
+++ b/compiler/types/FamInstEnv.lhs
@@ -5,59 +5,58 @@
FamInstEnv: Type checked family instance declarations
\begin{code}
-module FamInstEnv (
- Branched, Unbranched,
- FamInst(..), FamFlavor(..), FamInstBranch(..),
+{-# LANGUAGE GADTs #-}
+
+module FamInstEnv (
+ FamInst(..), FamFlavor(..), famInstAxiom, famInstTyCon, famInstRHS,
+ famInstsRepTyCons, famInstRepTyCon_maybe, dataFamInstRepTyCon,
+ pprFamInst, pprFamInstHdr, pprFamInsts,
+ mkImportedFamInst,
- famInstAxiom, famInstBranchRoughMatch,
- famInstsRepTyCons, famInstNthBranch, famInstSingleBranch,
- famInstBranchLHS, famInstBranches,
- toBranchedFamInst, toUnbranchedFamInst,
- famInstTyCon, famInstRepTyCon_maybe, dataFamInstRepTyCon,
- pprFamInst, pprFamInsts,
- pprFamFlavor,
- mkImportedFamInst,
+ FamInstEnvs, FamInstEnv, emptyFamInstEnv, emptyFamInstEnvs,
+ extendFamInstEnv, deleteFromFamInstEnv, extendFamInstEnvList,
+ identicalFamInst, famInstEnvElts, familyInstances, orphNamesOfFamInst,
- FamInstEnv, FamInstEnvs,
- emptyFamInstEnvs, emptyFamInstEnv, famInstEnvElts, familyInstances,
- extendFamInstEnvList, extendFamInstEnv, deleteFromFamInstEnv,
- identicalFamInst, orphNamesOfFamInst,
+ -- * CoAxioms
+ mkCoAxBranch, mkBranchedCoAxiom, mkUnbranchedCoAxiom, mkSingleCoAxiom,
+ computeAxiomIncomps,
FamInstMatch(..),
- lookupFamInstEnv, lookupFamInstEnvConflicts, lookupFamInstEnvConflicts',
-
- isDominatedBy,
+ lookupFamInstEnv, lookupFamInstEnvConflicts,
+ isDominatedBy,
+
-- Normalisation
- topNormaliseType, normaliseType, normaliseTcApp
+ chooseBranch, topNormaliseType, normaliseType, normaliseTcApp
) where
#include "HsVersions.h"
-import TcType ( orphNamesOfTypes )
import InstEnv
import Unify
import Type
-import Coercion hiding ( substTy )
+import TcType ( orphNamesOfTypes )
import TypeRep
import TyCon
+import Coercion
import CoAxiom
import VarSet
import VarEnv
import Name
-import NameSet
import UniqFM
import Outputable
import Maybes
import Util
+import Pair
+import SrcLoc
+import NameSet
import FastString
\end{code}
-
%************************************************************************
%* *
- Type checked family instance heads
+ Type checked family instance heads
%* *
%************************************************************************
@@ -69,80 +68,40 @@ Note [FamInsts and CoAxioms]
* A CoAxiom is a System-FC thing: it can relate any two types
* A FamInst is a Haskell source-language thing, corresponding
- to a type/data family instance declaration.
+ to a type/data family instance declaration.
- The FamInst contains a CoAxiom, which is the evidence
for the instance
- - The LHSs of the CoAxiom branches are always of form
- F ty1 .. tyn where F is a type family
-
-* A FamInstBranch corresponds to a CoAxBranch -- it represents
- one alternative in a branched family instance. We could theoretically
- not have FamInstBranches and just use the CoAxBranches within
- the CoAxiom stored in the FamInst, but for one problem: we want to
- cache the "rough match" top-level tycon names for quick matching.
- This data is not stored in a CoAxBranch, so we use FamInstBranches
- instead.
-
-Note [fi_branched field]
-~~~~~~~~~~~~~~~~~~~~~~~~
-A FamInst stores whether or not it was declared with "type instance where"
-for two reasons:
- 1. for accurate pretty-printing; and
- 2. because confluent overlap is disallowed between branches
- declared in groups.
-Note that this "branched-ness" is properly associated with the FamInst,
-which thinks about overlap, and not in the CoAxiom, which blindly
-assumes that it is part of a consistent axiom set.
-
-A "branched" instance with fi_branched=True can have just one branch, however.
-
-Note [Why we need fib_rhs]
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-It may at first seem unnecessary to store the right-hand side of an equation
-in a FamInstBranch. After all, FamInstBranches are used only for matching a
-family application; the underlying CoAxiom is used to perform the actual
-simplification.
-
-However, we do need to know the rhs field during conflict checking to support
-confluent overlap. When two unbranched instances have overlapping left-hand
-sides, we check if the right-hand sides are coincident in the region of overlap.
-This check requires fib_rhs. See lookupFamInstEnvConflicts.
+ - The LHS of the CoAxiom is always of form F ty1 .. tyn
+ where F is a type family
\begin{code}
-data FamInst br -- See Note [FamInsts and CoAxioms], Note [Branched axioms] in CoAxiom
- = FamInst { fi_axiom :: CoAxiom br -- The new coercion axiom introduced
- -- by this family instance
- , fi_flavor :: FamFlavor
- , fi_branched :: Bool -- True <=> declared with "type instance where"
- -- See Note [fi_branched field]
-
- -- Everything below here is a redundant,
- -- cached version of the two things above,
- -- except that the TyVars are freshened in the FamInstBranches
- , fi_branches :: BranchList FamInstBranch br
- -- Haskell-source-language view of
- -- a CoAxBranch
- , fi_fam :: Name -- Family name
- -- INVARIANT: fi_fam = name of fi_axiom.co_ax_tc
- }
-
-data FamInstBranch
- = FamInstBranch
- { fib_tvs :: [TyVar] -- Bound type variables
+data FamInst -- See Note [FamInsts and CoAxioms]
+ = FamInst { fi_axiom :: CoAxiom Unbranched -- The new coercion axiom introduced
+ -- by this family instance
+ , fi_flavor :: FamFlavor
+
+ -- Everything below here is a redundant,
+ -- cached version of the two things above
+ -- except that the TyVars are freshened
+ , fi_fam :: Name -- Family name
+
+ -- Used for "rough matching"; same idea as for class instances
+ -- See Note [Rough-match field] in InstEnv
+ , fi_tcs :: [Maybe Name] -- Top of type args
+ -- INVARIANT: fi_tcs = roughMatchTcs fi_tys
+
+ -- Used for "proper matching"; ditto
+ , fi_tvs :: [TyVar] -- Template tyvars for full match
-- Like ClsInsts, these variables are always
-- fresh. See Note [Template tyvars are fresh]
-- in InstEnv
- , fib_lhs :: [Type] -- Type patterns
-
- , fib_rhs :: Type -- RHS of family instance
- -- See Note [Why we need fib_rhs]
+ , fi_tys :: [Type] -- and its arg types
+ -- INVARIANT: fi_tvs = coAxiomTyVars fi_axiom
- , fib_tcs :: [Maybe Name] -- Used for "rough matching" during typechecking
- -- In 1-1 correspondence with fib_lhs
- -- see Note [Rough-match field] in InstEnv
- }
+ , fi_rhs :: Type -- the RHS, with its freshened vars
+ }
data FamFlavor
= SynFamilyInst -- A synonym family
@@ -152,50 +111,35 @@ data FamFlavor
\begin{code}
-- Obtain the axiom of a family instance
-famInstAxiom :: FamInst br -> CoAxiom br
+famInstAxiom :: FamInst -> CoAxiom Unbranched
famInstAxiom = fi_axiom
-famInstTyCon :: FamInst br -> TyCon
-famInstTyCon = co_ax_tc . fi_axiom
-
-famInstNthBranch :: FamInst br -> Int -> FamInstBranch
-famInstNthBranch (FamInst { fi_branches = branches }) index
- = ASSERT( 0 <= index && index < (length $ fromBranchList branches) )
- brListNth branches index
+-- Split the left-hand side of the FamInst
+famInstSplitLHS :: FamInst -> (TyCon, [Type])
+famInstSplitLHS (FamInst { fi_axiom = axiom, fi_tys = lhs })
+ = (coAxiomTyCon axiom, lhs)
-famInstSingleBranch :: FamInst Unbranched -> FamInstBranch
-famInstSingleBranch (FamInst { fi_branches = FirstBranch branch }) = branch
+-- Get the RHS of the FamInst
+famInstRHS :: FamInst -> Type
+famInstRHS = fi_rhs
-toBranchedFamInst :: FamInst br -> FamInst Branched
-toBranchedFamInst (FamInst ax flav grp branches fam)
- = FamInst (toBranchedAxiom ax) flav grp (toBranchedList branches) fam
-
-toUnbranchedFamInst :: FamInst br -> FamInst Unbranched
-toUnbranchedFamInst (FamInst ax flav grp branches fam)
- = FamInst (toUnbranchedAxiom ax) flav grp (toUnbranchedList branches) fam
-
-famInstBranches :: FamInst br -> BranchList FamInstBranch br
-famInstBranches = fi_branches
-
-famInstBranchLHS :: FamInstBranch -> [Type]
-famInstBranchLHS = fib_lhs
-
-famInstBranchRoughMatch :: FamInstBranch -> [Maybe Name]
-famInstBranchRoughMatch = fib_tcs
+-- Get the family TyCon of the FamInst
+famInstTyCon :: FamInst -> TyCon
+famInstTyCon = coAxiomTyCon . famInstAxiom
-- Return the representation TyCons introduced by data family instances, if any
-famInstsRepTyCons :: [FamInst br] -> [TyCon]
+famInstsRepTyCons :: [FamInst] -> [TyCon]
famInstsRepTyCons fis = [tc | FamInst { fi_flavor = DataFamilyInst tc } <- fis]
-- Extracts the TyCon for this *data* (or newtype) instance
-famInstRepTyCon_maybe :: FamInst br -> Maybe TyCon
-famInstRepTyCon_maybe fi
+famInstRepTyCon_maybe :: FamInst -> Maybe TyCon
+famInstRepTyCon_maybe fi
= case fi_flavor fi of
DataFamilyInst tycon -> Just tycon
SynFamilyInst -> Nothing
-dataFamInstRepTyCon :: FamInst br -> TyCon
-dataFamInstRepTyCon fi
+dataFamInstRepTyCon :: FamInst -> TyCon
+dataFamInstRepTyCon fi
= case fi_flavor fi of
DataFamilyInst tycon -> tycon
SynFamilyInst -> pprPanic "dataFamInstRepTyCon" (ppr fi)
@@ -208,44 +152,46 @@ dataFamInstRepTyCon fi
%************************************************************************
\begin{code}
-instance NamedThing (FamInst br) where
+instance NamedThing FamInst where
getName = coAxiomName . fi_axiom
-instance Outputable (FamInst br) where
+instance Outputable FamInst where
ppr = pprFamInst
-- Prints the FamInst as a family instance declaration
-pprFamInst :: FamInst br -> SDoc
-pprFamInst (FamInst { fi_branches = brs, fi_flavor = SynFamilyInst
- , fi_branched = True, fi_axiom = axiom })
- = hang (ptext (sLit "type instance where"))
- 2 (vcat [pprCoAxBranchHdr axiom i | i <- brListIndices brs])
-
-pprFamInst fi@(FamInst { fi_flavor = flavor
- , fi_branched = False, fi_axiom = ax })
- = pprFamFlavor flavor <+> pp_instance
- <+> pprCoAxBranchHdr ax 0
+pprFamInst :: FamInst -> SDoc
+pprFamInst famInst
+ = hang (pprFamInstHdr famInst)
+ 2 (vcat [ ifPprDebug (ptext (sLit "Coercion axiom:") <+> ppr ax)
+ , ifPprDebug (ptext (sLit "RHS:") <+> ppr (famInstRHS famInst))
+ , ptext (sLit "--") <+> pprDefinedAt (getName famInst)])
where
+ ax = fi_axiom famInst
+
+pprFamInstHdr :: FamInst -> SDoc
+pprFamInstHdr fi@(FamInst {fi_flavor = flavor})
+ = pprTyConSort <+> pp_instance <+> pprHead
+ where
+ (fam_tc, tys) = famInstSplitLHS fi
+
-- For *associated* types, say "type T Int = blah"
-- For *top level* type instances, say "type instance T Int = blah"
pp_instance
- | isTyConAssoc (famInstTyCon fi) = empty
- | otherwise = ptext (sLit "instance")
-
-pprFamInst _ = panic "pprFamInst"
-
-pprFamFlavor :: FamFlavor -> SDoc
-pprFamFlavor flavor
- = case flavor of
- SynFamilyInst -> ptext (sLit "type")
- DataFamilyInst tycon
- | isDataTyCon tycon -> ptext (sLit "data")
- | isNewTyCon tycon -> ptext (sLit "newtype")
- | isAbstractTyCon tycon -> ptext (sLit "data")
- | otherwise -> ptext (sLit "WEIRD") <+> ppr tycon
-
-pprFamInsts :: [FamInst br] -> SDoc
+ | isTyConAssoc fam_tc = empty
+ | otherwise = ptext (sLit "instance")
+
+ pprHead = pprTypeApp fam_tc tys
+ pprTyConSort = case flavor of
+ SynFamilyInst -> ptext (sLit "type")
+ DataFamilyInst tycon
+ | isDataTyCon tycon -> ptext (sLit "data")
+ | isNewTyCon tycon -> ptext (sLit "newtype")
+ | isAbstractTyCon tycon -> ptext (sLit "data")
+ | otherwise -> ptext (sLit "WEIRD") <+> ppr tycon
+
+pprFamInsts :: [FamInst] -> SDoc
pprFamInsts finsts = vcat (map pprFamInst finsts)
+
\end{code}
Note [Lazy axiom match]
@@ -264,55 +210,39 @@ not in the parameter list) and we assert the consistency of names there
also.
\begin{code}
-
-- Make a family instance representation from the information found in an
-- interface file. In particular, we get the rough match info from the iface
-- (instead of computing it here).
mkImportedFamInst :: Name -- Name of the family
- -> Bool -- is this a branched instance?
- -> [[Maybe Name]] -- Rough match info, per branch
- -> CoAxiom Branched -- Axiom introduced
- -> FamInst Branched -- Resulting family instance
-mkImportedFamInst fam branched roughs axiom
+ -> [Maybe Name] -- Rough match info
+ -> CoAxiom Unbranched -- Axiom introduced
+ -> FamInst -- Resulting family instance
+mkImportedFamInst fam mb_tcs axiom
= FamInst {
- fi_fam = fam,
- fi_axiom = axiom,
- fi_flavor = flavor,
- fi_branched = branched,
- fi_branches = branches }
- where
- -- Lazy match (See note [Lazy axiom match])
- CoAxiom { co_ax_branches = axBranches }
- = ASSERT( fam == tyConName (coAxiomTyCon axiom) )
- axiom
-
- branches = toBranchList $ map mk_imp_fam_inst_branch $
- (roughs `zipLazy` fromBranchList axBranches)
- -- Lazy zip (See note [Lazy axiom match])
-
- mk_imp_fam_inst_branch (mb_tcs, ~(CoAxBranch { cab_tvs = tvs
- , cab_lhs = lhs
- , cab_rhs = rhs }))
- -- Lazy match (See note [Lazy axiom match])
- = FamInstBranch { fib_tvs = tvs
- , fib_lhs = lhs
- , fib_rhs = rhs
- , fib_tcs = mb_tcs }
+ fi_fam = fam,
+ fi_tcs = mb_tcs,
+ fi_tvs = tvs,
+ fi_tys = tys,
+ fi_rhs = rhs,
+ fi_axiom = axiom,
+ fi_flavor = flavor }
+ where
+ -- See Note [Lazy axiom match]
+ ~(CoAxiom { co_ax_branches =
+ ~(FirstBranch ~(CoAxBranch { cab_lhs = tys
+ , cab_tvs = tvs
+ , cab_rhs = rhs })) }) = axiom
-- Derive the flavor for an imported FamInst rather disgustingly
-- Maybe we should store it in the IfaceFamInst?
- flavor
- | FirstBranch (CoAxBranch { cab_rhs = rhs }) <- axBranches
- , Just (tc, _) <- splitTyConApp_maybe rhs
- , Just ax' <- tyConFamilyCoercion_maybe tc
- , (toBranchedAxiom ax') == axiom
- = DataFamilyInst tc
-
- | otherwise
- = SynFamilyInst
+ flavor = case splitTyConApp_maybe rhs of
+ Just (tc, _)
+ | Just ax' <- tyConFamilyCoercion_maybe tc
+ , ax' == axiom
+ -> DataFamilyInst tc
+ _ -> SynFamilyInst
\end{code}
-
%************************************************************************
%* *
FamInstEnv
@@ -335,7 +265,7 @@ Neverthless it is still useful to have data families in the FamInstEnv:
- For finding the representation type...see FamInstEnv.topNormaliseType
and its call site in Simplify
- - In standalone deriving instance Eq (T [Int]) we need to find the
+ - In standalone deriving instance Eq (T [Int]) we need to find the
representation type for T [Int]
Note [Varying number of patterns for data family axioms]
@@ -365,7 +295,7 @@ type FamInstEnvs = (FamInstEnv, FamInstEnv)
-- External package inst-env, Home-package inst-env
newtype FamilyInstEnv
- = FamIE [FamInst Branched] -- The instances for a particular family, in any order
+ = FamIE [FamInst] -- The instances for a particular family, in any order
instance Outputable FamilyInstEnv where
ppr (FamIE fs) = ptext (sLit "FamIE") <+> vcat (map ppr fs)
@@ -380,16 +310,16 @@ emptyFamInstEnvs = (emptyFamInstEnv, emptyFamInstEnv)
emptyFamInstEnv :: FamInstEnv
emptyFamInstEnv = emptyUFM
-famInstEnvElts :: FamInstEnv -> [FamInst Branched]
+famInstEnvElts :: FamInstEnv -> [FamInst]
famInstEnvElts fi = [elt | FamIE elts <- eltsUFM fi, elt <- elts]
-familyInstances :: (FamInstEnv, FamInstEnv) -> TyCon -> [FamInst Branched]
+familyInstances :: (FamInstEnv, FamInstEnv) -> TyCon -> [FamInst]
familyInstances (pkg_fie, home_fie) fam
= get home_fie ++ get pkg_fie
where
get env = case lookupUFM env fam of
Just (FamIE insts) -> insts
- Nothing -> []
+ Nothing -> []
-- | Collects the names of the concrete types and type constructors that
-- make up the LHS of a type family instance. For instance,
@@ -398,28 +328,28 @@ familyInstances (pkg_fie, home_fie) fam
-- `type instance Foo (F (G (H a))) b = ...` would yield [F,G,H]
--
-- Used in the implementation of ":info" in GHCi.
-orphNamesOfFamInst :: FamInst Branched -> NameSet
+orphNamesOfFamInst :: FamInst -> NameSet
orphNamesOfFamInst
= orphNamesOfTypes . concat . brListMap cab_lhs . coAxiomBranches . fi_axiom
-extendFamInstEnvList :: FamInstEnv -> [FamInst br] -> FamInstEnv
+extendFamInstEnvList :: FamInstEnv -> [FamInst] -> FamInstEnv
extendFamInstEnvList inst_env fis = foldl extendFamInstEnv inst_env fis
-extendFamInstEnv :: FamInstEnv -> FamInst br -> FamInstEnv
+extendFamInstEnv :: FamInstEnv -> FamInst -> FamInstEnv
extendFamInstEnv inst_env ins_item@(FamInst {fi_fam = cls_nm})
- = addToUFM_C add inst_env cls_nm (FamIE [ins_item_br])
+ = addToUFM_C add inst_env cls_nm (FamIE [ins_item])
where
- ins_item_br = toBranchedFamInst ins_item
- add (FamIE items) _ = FamIE (ins_item_br:items)
+ add (FamIE items) _ = FamIE (ins_item:items)
-deleteFromFamInstEnv :: FamInstEnv -> FamInst br -> FamInstEnv
+deleteFromFamInstEnv :: FamInstEnv -> FamInst -> FamInstEnv
deleteFromFamInstEnv inst_env fam_inst@(FamInst {fi_fam = fam_nm})
= adjustUFM adjust inst_env fam_nm
where
adjust :: FamilyInstEnv -> FamilyInstEnv
- adjust (FamIE items) = FamIE (filterOut (identicalFamInst fam_inst) items)
+ adjust (FamIE items)
+ = FamIE (filterOut (identicalFamInst fam_inst) items)
-identicalFamInst :: FamInst br1 -> FamInst br2 -> Bool
+identicalFamInst :: FamInst -> FamInst -> Bool
-- Same LHS, *and* the instance is defined in the same module
-- Used for overriding in GHCi
identicalFamInst (FamInst { fi_axiom = ax1 }) (FamInst { fi_axiom = ax2 })
@@ -439,38 +369,26 @@ identicalFamInst (FamInst { fi_axiom = ax1 }) (FamInst { fi_axiom = ax2 })
lhs1 = coAxBranchLHS br1
lhs2 = coAxBranchLHS br2
rn_env = rnBndrs2 (mkRnEnv2 emptyInScopeSet) tvs1 tvs2
-
+
\end{code}
%************************************************************************
%* *
- Looking up a family instance
+ Compatibility
%* *
%************************************************************************
-@lookupFamInstEnv@ looks up in a @FamInstEnv@, using a one-way match.
-Multiple matches are only possible in case of type families (not data
-families), and then, it doesn't matter which match we choose (as the
-instances are guaranteed confluent).
+Note [Compatibility]
+~~~~~~~~~~~~~~~~~~~~
+Two patterns are /compatible/ if either of the following conditions hold:
+1) The patterns are apart.
+2) The patterns unify with a substitution S, and their right hand sides
+equal under that substitution.
-We return the matching family instances and the type instance at which it
-matches. For example, if we lookup 'T [Int]' and have a family instance
-
- data instance T [a] = ..
-
-desugared to
-
- data :R42T a = ..
- coe :Co:R42T a :: T [a] ~ :R42T a
-
-we return the matching instance '(FamInst{.., fi_tycon = :R42T}, Int)'.
-
-Note [Branched instance checking]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+For open type families, only compatible instances are allowed. For closed
+type families, the story is slightly more complicated. Consider the following:
-Consider the following:
-
-type instance where
+type family F a where
F Int = Bool
F a = Int
@@ -481,8 +399,8 @@ Should that type-check? No. We need to allow for the possibility that 'a'
might be Int and therefore 'F a' should be Bool. We can simplify 'F a' to Int
only when we can be sure that 'a' is not Int.
-To achieve this, after finding a possible match within an instance, we have to
-go back to all previous FamInstBranchess and check that, under the
+To achieve this, after finding a possible match within the equations, we have to
+go back to all previous equations and check that, under the
substitution induced by the match, other branches are surely apart. (See
[Apartness] in types/Unify.lhs.) This is similar to what happens with class
instance selection, when we need to guarantee that there is only a match and
@@ -502,70 +420,148 @@ type family H y
Now, we want to simplify (G (H Char)). We can't, because (H Char) might later
simplify to be Int. So, (G (H Char)) is stuck, for now.
-ALTERNATE APPROACH: As we are processing the branches, we could check if a
-branch is not surely apart from an application but does not match that
-application. If this happens, there is no possible match and we can fail right
-away. This might be more efficient.
+While everything above is quite sound, it isn't as expressive as we'd like.
+Consider this:
-Note [Early failure optimisation for branched instances]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-As we're searching through the instances for a match, it is possible that we
-find a branch within an instance that matches, but a previous branch is not
-surely apart from the target application. In this case, we can abort the
-search, because any other instance that matches will necessarily overlap with
-the instance we're currently searching. Because overlap among branched
-instances is disallowed, we know that that no such other instance exists.
-
-Note [Confluence checking within branched instances]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-GHC allows type family instances to have overlapping patterns as long as the
-right-hand sides are coincident in the region of overlap. Can we extend this
-notion of confluent overlap to branched instances? Not in any obvious way.
+type family J a where
+ J Int = Int
+ J a = a
-Consider this:
+Can we simplify (J b) to b? Sure we can. Yes, the first equation matches if
+b is instantiated with Int, but the RHSs coincide there, so it's all OK.
-type instance where
- F Int = Int
- F a = a
-
-Without confluence checking (in other words, as implemented), we cannot now
-simplify an application of (F b) -- b might unify with Int later on, so this
-application is stuck. However, it would seem easy to just check that, in the
-region of overlap, (i.e. b |-> Int), the right-hand sides coincide, so we're
-OK. The problem happens when we are simplifying an application (F (G a)),
-where (G a) is stuck. What, now, is the region of overlap? We can't soundly
-simplify (F (G a)) without knowing that the right-hand sides are confluent
-in the region of overlap, but we also can't in any obvious way identify the
-region of overlap. We don't want to do analysis on the instances of G, because
-that is not sound in a world with open type families. (If G were known to be
-closed, there might be a way forward here.) To find the region of overlap,
-it is conceivable that we might convert (G a) to some fresh type variable and
-then unify, but we must be careful to convert every (G a) to the same fresh
-type variable. And then, what if there is an (H a) lying around? It all seems
-rather subtle, error-prone, confusing, and probably won't help anyone. So,
-we're not doing it.
-
-So, why is this not a problem with non-branched confluent overlap? Because
-we don't need to verify that an application is apart from anything. The
-non-branched confluent overlap check happens when we add the instance to the
-environment -- we're unifying among patterns, which cannot contain type family
-applications. So, we're safe there and can continue supporting that feature.
+So, the rule is this: when looking up a branch in a closed type family, we
+find a branch that matches the target, but then we make sure that the target
+is apart from every previous *incompatible* branch. We don't check the
+branches that are compatible with the matching branch, because they are eithe
+irrelevant (clause 1 of compatible) or benign (clause 2 of compatible).
+
+\begin{code}
+
+compatibleBranches :: CoAxBranch -> CoAxBranch -> Bool
+compatibleBranches (CoAxBranch { cab_lhs = lhs1, cab_rhs = rhs1 })
+ (CoAxBranch { cab_lhs = lhs2, cab_rhs = rhs2 })
+ = case tcApartTys instanceBindFun lhs1 lhs2 of
+ SurelyApart -> True
+ Unifiable subst
+ | Type.substTy subst rhs1 `eqType` Type.substTy subst rhs2
+ -> True
+ _ -> False
+
+-- takes a CoAxiom with unknown branch incompatibilities and computes
+-- the compatibilities
+computeAxiomIncomps :: CoAxiom br -> CoAxiom br
+computeAxiomIncomps ax@(CoAxiom { co_ax_branches = branches })
+ = ax { co_ax_branches = go [] branches }
+ where
+ go :: [CoAxBranch] -> BranchList CoAxBranch br -> BranchList CoAxBranch br
+ go prev_branches (FirstBranch br)
+ = FirstBranch (br { cab_incomps = mk_incomps br prev_branches })
+ go prev_branches (NextBranch br tail)
+ = let br' = br { cab_incomps = mk_incomps br prev_branches } in
+ NextBranch br' (go (br' : prev_branches) tail)
+
+ mk_incomps :: CoAxBranch -> [CoAxBranch] -> [CoAxBranch]
+ mk_incomps br = filter (not . compatibleBranches br)
+
+\end{code}
+
+%************************************************************************
+%* *
+ Constructing axioms
+ These functions are here because tidyType / tcApartTys
+ are not available in CoAxiom
+%* *
+%************************************************************************
+
+Note [Tidy axioms when we build them]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+We print out axioms and don't want to print stuff like
+ F k k a b = ...
+Instead we must tidy those kind variables. See Trac #7524.
+
+\begin{code}
+mkCoAxBranch :: [TyVar] -- original, possibly stale, tyvars
+ -> [Type] -- LHS patterns
+ -> Type -- RHS
+ -> SrcSpan
+ -> CoAxBranch
+mkCoAxBranch tvs lhs rhs loc
+ = CoAxBranch { cab_tvs = tvs1
+ , cab_lhs = tidyTypes env lhs
+ , cab_rhs = tidyType env rhs
+ , cab_loc = loc
+ , cab_incomps = placeHolderIncomps }
+ where
+ (env, tvs1) = tidyTyVarBndrs emptyTidyEnv tvs
+ -- See Note [Tidy axioms when we build them]
+
+-- all of the following code is here to avoid mutual dependencies with
+-- Coercion
+mkBranchedCoAxiom :: Name -> TyCon -> [CoAxBranch] -> CoAxiom Branched
+mkBranchedCoAxiom ax_name fam_tc branches
+ = computeAxiomIncomps $
+ CoAxiom { co_ax_unique = nameUnique ax_name
+ , co_ax_name = ax_name
+ , co_ax_tc = fam_tc
+ , co_ax_implicit = False
+ , co_ax_branches = toBranchList branches }
+
+mkUnbranchedCoAxiom :: Name -> TyCon -> CoAxBranch -> CoAxiom Unbranched
+mkUnbranchedCoAxiom ax_name fam_tc branch
+ = CoAxiom { co_ax_unique = nameUnique ax_name
+ , co_ax_name = ax_name
+ , co_ax_tc = fam_tc
+ , co_ax_implicit = False
+ , co_ax_branches = FirstBranch (branch { cab_incomps = [] }) }
+
+mkSingleCoAxiom :: Name -> [TyVar] -> TyCon -> [Type] -> Type -> CoAxiom Unbranched
+mkSingleCoAxiom ax_name tvs fam_tc lhs_tys rhs_ty
+ = CoAxiom { co_ax_unique = nameUnique ax_name
+ , co_ax_name = ax_name
+ , co_ax_tc = fam_tc
+ , co_ax_implicit = False
+ , co_ax_branches = FirstBranch (branch { cab_incomps = [] }) }
+ where
+ branch = mkCoAxBranch tvs lhs_tys rhs_ty (getSrcSpan ax_name)
+\end{code}
+
+%************************************************************************
+%* *
+ Looking up a family instance
+%* *
+%************************************************************************
+
+@lookupFamInstEnv@ looks up in a @FamInstEnv@, using a one-way match.
+Multiple matches are only possible in case of type families (not data
+families), and then, it doesn't matter which match we choose (as the
+instances are guaranteed confluent).
+
+We return the matching family instances and the type instance at which it
+matches. For example, if we lookup 'T [Int]' and have a family instance
+
+ data instance T [a] = ..
+
+desugared to
+
+ data :R42T a = ..
+ coe :Co:R42T a :: T [a] ~ :R42T a
+
+we return the matching instance '(FamInst{.., fi_tycon = :R42T}, Int)'.
\begin{code}
+
-- when matching a type family application, we get a FamInst,
--- a 0-based index of the branch that matched, and the list of types
--- the axiom should be applied to
-data FamInstMatch = FamInstMatch { fim_instance :: FamInst Branched
- , fim_index :: BranchIndex
+-- and the list of types the axiom should be applied to
+data FamInstMatch = FamInstMatch { fim_instance :: FamInst
, fim_tys :: [Type]
}
+ -- See Note [Over-saturated matches]
instance Outputable FamInstMatch where
ppr (FamInstMatch { fim_instance = inst
- , fim_index = ind
, fim_tys = tys })
- = ptext (sLit "match with") <+> parens (ppr inst)
- <> brackets (ppr ind) <+> ppr tys
+ = ptext (sLit "match with") <+> parens (ppr inst) <+> ppr tys
lookupFamInstEnv
:: FamInstEnvs
@@ -574,48 +570,14 @@ lookupFamInstEnv
-- Precondition: the tycon is saturated (or over-saturated)
lookupFamInstEnv
- = lookup_fam_inst_env match True
- where
- match :: MatchFun
- match seen (FamInstBranch { fib_tvs = tpl_tvs
- , fib_lhs = tpl_tys })
- _ match_tys
- = ASSERT( tyVarsOfTypes match_tys `disjointVarSet` tpl_tv_set )
- -- Unification will break badly if the variables overlap
- -- They shouldn't because we allocate separate uniques for them
- case tcMatchTys tpl_tv_set tpl_tys match_tys of
- -- success
- Just subst
- | checkConflict seen match_tys
- -> (Nothing, StopSearching) -- we found an incoherence, so stop searching
- -- see Note [Early failure optimisation for branched instances]
-
- | otherwise
- -> (Just subst, KeepSearching)
-
- -- failure; instance not relevant
- Nothing -> (Nothing, KeepSearching)
- where
- tpl_tv_set = mkVarSet tpl_tvs
-
- -- see Note [Branched instance checking]
- checkConflict :: [FamInstBranch] -- the previous branches in the instance that matched
- -> [Type] -- the types in the tyfam application we are matching
- -> Bool -- is there a conflict?
- checkConflict [] _ = False
- checkConflict ((FamInstBranch { fib_lhs = tpl_tys }) : rest) match_tys
- -- see Note [Confluence checking within branched instances]
- | SurelyApart <- tcApartTys instanceBindFun tpl_tys match_tys
- = checkConflict rest match_tys
- | otherwise
- = True
+ = lookup_fam_inst_env match
+ where
+ match _ tpl_tvs tpl_tys tys = tcMatchTys tpl_tvs tpl_tys tys
lookupFamInstEnvConflicts
:: FamInstEnvs
- -> Bool -- True <=> we are checking part of a group with other branches
- -> TyCon -- The TyCon of the family
- -> FamInstBranch -- the putative new instance branch
- -> [FamInstMatch] -- Conflicting branches
+ -> FamInst -- Putative new instance
+ -> [FamInstMatch] -- Conflicting matches (don't look at the fim_tys field)
-- E.g. when we are about to add
-- f : type instance F [a] = a->a
-- we do (lookupFamInstConflicts f [b])
@@ -623,67 +585,26 @@ lookupFamInstEnvConflicts
--
-- Precondition: the tycon is saturated (or over-saturated)
-lookupFamInstEnvConflicts envs grp tc
- (FamInstBranch { fib_lhs = tys, fib_rhs = rhs })
- = lookup_fam_inst_env my_unify False envs tc tys
+lookupFamInstEnvConflicts envs fam_inst@(FamInst { fi_axiom = new_axiom })
+ = lookup_fam_inst_env my_unify envs fam tys
where
- my_unify :: MatchFun
- my_unify _ (FamInstBranch { fib_tvs = tpl_tvs, fib_lhs = tpl_tys
- , fib_rhs = tpl_rhs }) old_grp match_tys
- = ASSERT( tyVarsOfTypes tys `disjointVarSet` mkVarSet tpl_tvs )
+ (fam, tys) = famInstSplitLHS fam_inst
+ -- In example above, fam tys' = F [b]
+
+ my_unify (FamInst { fi_axiom = old_axiom }) tpl_tvs tpl_tys _
+ = ASSERT2( tyVarsOfTypes tys `disjointVarSet` tpl_tvs,
+ (ppr fam <+> ppr tys) $$
+ (ppr tpl_tvs <+> ppr tpl_tys) )
-- Unification will break badly if the variables overlap
-- They shouldn't because we allocate separate uniques for them
- case tcUnifyTys instanceBindFun tpl_tys match_tys of
- Just subst
- | isDataFamilyTyCon tc
- || grp
- || old_grp
- || rhs_conflict tpl_rhs rhs subst
- -> (Just subst, KeepSearching)
- | otherwise -- confluent overlap
- -> (Nothing, KeepSearching)
- -- irrelevant instance
- Nothing -> (Nothing, KeepSearching)
-
- -- checks whether two RHSs are distinct, under a unifying substitution
- -- Note [Family instance overlap conflicts]
- rhs_conflict :: Type -> Type -> TvSubst -> Bool
- rhs_conflict rhs1 rhs2 subst
- = not (rhs1' `eqType` rhs2')
- where
- rhs1' = substTy subst rhs1
- rhs2' = substTy subst rhs2
-
--- This variant is called when we want to check if the conflict is only in the
--- home environment (see FamInst.addLocalFamInst)
-lookupFamInstEnvConflicts' :: FamInstEnv -> Bool -> TyCon
- -> FamInstBranch -> [FamInstMatch]
-lookupFamInstEnvConflicts' env
- = lookupFamInstEnvConflicts (emptyFamInstEnv, env)
-\end{code}
+ if compatibleBranches (coAxiomSingleBranch old_axiom) (new_branch)
+ then Nothing
+ else Just noSubst
+ -- Note [Family instance overlap conflicts]
-Note [lookup_fam_inst_env' implementation]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-To reduce code duplication, both lookups during simplification and conflict
-checking are routed through lookup_fam_inst_env', which looks for a
-matching/unifying branch compared to some target. In the simplification
-case, the search is for a match for a target application; in the conflict-
-checking case, the search is for a unifier for a putative new instance branch.
-
-The two uses are differentiated by different MatchFuns, which look at a given
-branch to see if it is relevant and whether the search should continue. The
-the branch is relevant (i.e. matches or unifies), Just subst is
-returned; if the instance is not relevant, Nothing is returned. The MatchFun
-also indicates what the search algorithm should do next: it could
-KeepSearching or StopSearching.
-
-When to StopSearching? See Note [Early failure optimisation for branched instances]
-
-For class instances, these two variants of lookup are combined into one
-function (cf, @InstEnv@). We don't do that for family instances as the
-results of matching and unification are used in two different contexts.
-Moreover, matching is the wildly more frequently used operation in the case of
-indexed synonyms and we don't want to slow that down by needless unification.
+ noSubst = panic "lookupFamInstEnvConflicts noSubst"
+ new_branch = coAxiomSingleBranch new_axiom
+\end{code}
Note [Family instance overlap conflicts]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -691,86 +612,83 @@ Note [Family instance overlap conflicts]
conflict (as these instances imply injective type mappings).
- In the case of type family instances, overlap is admitted as long as
- the neither instance declares an instance group and the right-hand
- sides of the overlapping rules coincide under the overlap substitution.
- For example:
+ the right-hand sides of the overlapping rules coincide under the
+ overlap substitution. eg
type instance F a Int = a
type instance F Int b = b
- These two overlap on (F Int Int) but then both RHSs are Int,
+ These two overlap on (F Int Int) but then both RHSs are Int,
so all is well. We require that they are syntactically equal;
anything else would be difficult to test for at this stage.
\begin{code}
------------------------------------------------------------
-data ContSearch = KeepSearching
- | StopSearching
-
-- Might be a one-way match or a unifier
-type MatchFun = [FamInstBranch] -- the previous branches in the instance
- -> FamInstBranch -- the individual branch to check
- -> Bool -- is this branch a part of a branched instance?
- -> [Type] -- the types to match against
- -> (Maybe TvSubst, ContSearch)
-
-type OneSidedMatch = Bool -- Are optimisations that are only valid for
- -- one sided matches allowed?
+type MatchFun = FamInst -- The FamInst template
+ -> TyVarSet -> [Type] -- fi_tvs, fi_tys of that FamInst
+ -> [Type] -- Target to match against
+ -> Maybe TvSubst
lookup_fam_inst_env' -- The worker, local to this module
:: MatchFun
- -> OneSidedMatch
-> FamInstEnv
-> TyCon -> [Type] -- What we are looking for
-> [FamInstMatch]
-lookup_fam_inst_env' match_fun _one_sided ie fam tys
- | isFamilyTyCon fam
+lookup_fam_inst_env' match_fun ie fam match_tys
+ | isOpenFamilyTyCon fam
, Just (FamIE insts) <- lookupUFM ie fam
- = find match_fun tys insts -- The common case
+ = find insts -- The common case
| otherwise = []
-
-find :: MatchFun -> [Type] -> [FamInst Branched] -> [FamInstMatch]
-find _ _ [] = []
-find match_fun match_tys (inst@(FamInst { fi_branches = branches, fi_branched = is_branched }) : rest)
- = case findBranch [] (fromBranchList branches) 0 of
- (Just match, StopSearching) -> [match]
- (Just match, KeepSearching) -> match : find match_fun match_tys rest
- (Nothing, StopSearching) -> []
- (Nothing, KeepSearching) -> find match_fun match_tys rest
where
- rough_tcs = roughMatchTcs match_tys
-
- findBranch :: [FamInstBranch] -- the branches that have already been checked
- -> [FamInstBranch] -- still looking through these
- -> BranchIndex -- index of teh first of the "still looking" list
- -> (Maybe FamInstMatch, ContSearch)
- findBranch _ [] _ = (Nothing, KeepSearching)
- findBranch seen (branch@(FamInstBranch { fib_tvs = tvs, fib_tcs = mb_tcs }) : rest) ind
+
+ find [] = []
+ find (item@(FamInst { fi_tcs = mb_tcs, fi_tvs = tpl_tvs,
+ fi_tys = tpl_tys }) : rest)
+ -- Fast check for no match, uses the "rough match" fields
| instanceCantMatch rough_tcs mb_tcs
- = findBranch seen rest (ind+1) -- branch won't unify later; no need to add to 'seen'
+ = find rest
+
+ -- Proper check
+ | Just subst <- match_fun item (mkVarSet tpl_tvs) tpl_tys match_tys1
+ = (FamInstMatch { fim_instance = item
+ , fim_tys = substTyVars subst tpl_tvs `chkAppend` match_tys2 })
+ : find rest
+
+ -- No match => try next
| otherwise
- = case match_fun seen branch is_branched match_tys1 of
- (Nothing, KeepSearching) -> findBranch (branch : seen) rest (ind+1)
- (Nothing, StopSearching) -> (Nothing, StopSearching)
- (Just subst, cont) -> (Just match, cont)
- where
- match = FamInstMatch { fim_instance = inst
- , fim_index = ind
- , fim_tys = substTyVars subst tvs `chkAppend` match_tys2}
+ = find rest
+
where
- -- Deal with over-saturation
- -- See Note [Over-saturated matches]
- (match_tys1, match_tys2) = splitAtList mb_tcs match_tys
+ (rough_tcs, match_tys1, match_tys2) = split_tys tpl_tys
+
+ -- Precondition: the tycon is saturated (or over-saturated)
+
+ -- Deal with over-saturation
+ -- See Note [Over-saturated matches]
+ split_tys tpl_tys
+ | isSynFamilyTyCon fam
+ = pre_rough_split_tys
+
+ | otherwise
+ = let (match_tys1, match_tys2) = splitAtList tpl_tys match_tys
+ rough_tcs = roughMatchTcs match_tys1
+ in (rough_tcs, match_tys1, match_tys2)
+
+ (pre_match_tys1, pre_match_tys2) = splitAt (tyConArity fam) match_tys
+ pre_rough_split_tys
+ = (roughMatchTcs pre_match_tys1, pre_match_tys1, pre_match_tys2)
lookup_fam_inst_env -- The worker, local to this module
:: MatchFun
- -> OneSidedMatch
-> FamInstEnvs
-> TyCon -> [Type] -- What we are looking for
- -> [FamInstMatch] -- What was found
+ -> [FamInstMatch] -- Successful matches
-- Precondition: the tycon is saturated (or over-saturated)
-lookup_fam_inst_env match_fun one_sided (pkg_ie, home_ie) fam tys =
- lookup_fam_inst_env' match_fun one_sided home_ie fam tys ++
- lookup_fam_inst_env' match_fun one_sided pkg_ie fam tys
+
+lookup_fam_inst_env match_fun (pkg_ie, home_ie) fam tys =
+ lookup_fam_inst_env' match_fun home_ie fam tys ++
+ lookup_fam_inst_env' match_fun pkg_ie fam tys
+
\end{code}
Note [Over-saturated matches]
@@ -783,11 +701,19 @@ The type instance gives rise to a newtype TyCon (at a higher kind
which you can't do in Haskell!):
newtype FPair a b = FP (Either (a->b))
-Then looking up (F (Int,Bool) Char) will return a FamInstMatch
+Then looking up (F (Int,Bool) Char) will return a FamInstMatch
(FPair, [Int,Bool,Char])
The "extra" type argument [Char] just stays on the end.
+Because of eta-reduction of data family instances (see
+Note [Eta reduction for data family axioms] in TcInstDecls), we must
+handle data families and type families separately here. All instances
+of a type family must have the same arity, so we can precompute the split
+between the match_tys and the overflow tys. This is done in pre_rough_split_tys.
+For data instances, though, we need to re-split for each instance, because
+the breakdown might be different.
+
\begin{code}
-- checks if one LHS is dominated by a list of other branches
@@ -808,6 +734,72 @@ isDominatedBy branch branches
= isJust $ tcMatchTys (mkVarSet tvs) tys lhs
\end{code}
+%************************************************************************
+%* *
+ Choosing an axiom application
+%* *
+%************************************************************************
+
+The lookupFamInstEnv function does a nice job for *open* type families,
+but we also need to handle closed ones when normalising a type:
+
+\begin{code}
+
+-- The TyCon can be oversaturated. This works on both open and closed families
+chooseAxiom :: FamInstEnvs -> TyCon -> [Type] -> Maybe (Coercion, Type)
+chooseAxiom envs tc tys
+ | isOpenFamilyTyCon tc
+ , [FamInstMatch { fim_instance = fam_inst
+ , fim_tys = inst_tys }] <- lookupFamInstEnv envs tc tys
+ = let co = mkUnbranchedAxInstCo (famInstAxiom fam_inst) inst_tys
+ ty = pSnd (coercionKind co)
+ in Just (co, ty)
+
+ | Just ax <- isClosedSynFamilyTyCon_maybe tc
+ , Just (ind, inst_tys) <- chooseBranch ax tys
+ = let co = mkAxInstCo ax ind inst_tys
+ ty = pSnd (coercionKind co)
+ in Just (co, ty)
+
+ | otherwise
+ = Nothing
+
+-- The axiom can be oversaturated. (Closed families only.)
+chooseBranch :: CoAxiom Branched -> [Type] -> Maybe (BranchIndex, [Type])
+chooseBranch axiom tys
+ = do { let num_pats = coAxiomNumPats axiom
+ (target_tys, extra_tys) = splitAt num_pats tys
+ branches = coAxiomBranches axiom
+ ; (ind, inst_tys) <- findBranch (fromBranchList branches) 0 target_tys
+ ; return (ind, inst_tys ++ extra_tys) }
+
+-- The axiom must *not* be oversaturated
+findBranch :: [CoAxBranch] -- branches to check
+ -> BranchIndex -- index of current branch
+ -> [Type] -- target types
+ -> Maybe (BranchIndex, [Type])
+findBranch (CoAxBranch { cab_tvs = tpl_tvs, cab_lhs = tpl_lhs, cab_incomps = incomps }
+ : rest) ind target_tys
+ = case tcMatchTys (mkVarSet tpl_tvs) tpl_lhs target_tys of
+ Just subst -- matching worked. now, check for apartness.
+ | all (isSurelyApart
+ . tcApartTys instanceBindFun target_tys
+ . coAxBranchLHS) $ -- RAE: This is horribly inefficient
+ incomps
+ -> -- matching worked & we're apart from all incompatible branches. success
+ Just (ind, substTyVars subst tpl_tvs)
+
+ -- failure. keep looking
+ _ -> findBranch rest (ind+1) target_tys
+
+ where isSurelyApart SurelyApart = True
+ isSurelyApart _ = False
+
+-- fail if no branches left
+findBranch [] _ _ = Nothing
+
+\end{code}
+
%************************************************************************
%* *
@@ -820,8 +812,8 @@ topNormaliseType :: FamInstEnvs
-> Type
-> Maybe (Coercion, Type)
--- Get rid of *outermost* (or toplevel)
--- * type functions
+-- Get rid of *outermost* (or toplevel)
+-- * type functions
-- * newtypes
-- using appropriate coercions.
-- By "outer" we mean that toplevelNormaliseType guarantees to return
@@ -843,7 +835,7 @@ topNormaliseType env ty
= add_co nt_co rec_nts' nt_rhs
go rec_nts (TyConApp tc tys)
- | isFamilyTyCon tc -- Expand open tycons
+ | isFamilyTyCon tc -- Expand family tycons
, (co, ty) <- normaliseTcApp env tc tys
-- Note that normaliseType fully normalises 'tys',
-- wrt type functions but *not* newtypes
@@ -855,23 +847,18 @@ topNormaliseType env ty
go _ _ = Nothing
- add_co co rec_nts ty
+ add_co co rec_nts ty
= case go rec_nts ty of
Nothing -> Just (co, ty)
Just (co', ty') -> Just (mkTransCo co co', ty')
-
+
---------------
normaliseTcApp :: FamInstEnvs -> TyCon -> [Type] -> (Coercion, Type)
normaliseTcApp env tc tys
| isFamilyTyCon tc
- , [FamInstMatch { fim_instance = fam_inst
- , fim_index = fam_ind
- , fim_tys = inst_tys }] <- lookupFamInstEnv env tc ntys
- = let -- A matching family instance exists
- ax = famInstAxiom fam_inst
- co = mkAxInstCo ax fam_ind inst_tys
- rhs = mkAxInstRHS ax fam_ind inst_tys
+ , Just (co, rhs) <- chooseAxiom env tc ntys
+ = let -- A reduction is possible
first_coi = mkTransCo tycon_coi co
(rest_coi,nty) = normaliseType env rhs
fix_coi = mkTransCo first_coi rest_coi
@@ -879,26 +866,25 @@ normaliseTcApp env tc tys
(fix_coi, nty)
| otherwise -- No unique matching family instance exists;
- -- we do not do anything (including for newtypes)
+ -- we do not do anything
= (tycon_coi, TyConApp tc ntys)
where
- -- Normalise the arg types so that they'll match
+ -- Normalise the arg types so that they'll match
-- when we lookup in in the instance envt
(cois, ntys) = mapAndUnzip (normaliseType env) tys
tycon_coi = mkTyConAppCo tc cois
---------------
normaliseType :: FamInstEnvs -- environment with family instances
- -> Type -- old type
+ -> Type -- old type
-> (Coercion, Type) -- (coercion,new type), where
-- co :: old-type ~ new_type
-- Normalise the input type, by eliminating *all* type-function redexes
-- Returns with Refl if nothing happens
--- Does nothing to newtypes
-normaliseType env ty
- | Just ty' <- coreView ty = normaliseType env ty'
+normaliseType env ty
+ | Just ty' <- coreView ty = normaliseType env ty'
normaliseType env (TyConApp tc tys)
= normaliseTcApp env tc tys
normaliseType _env ty@(LitTy {}) = (Refl ty, ty)
diff --git a/compiler/types/OptCoercion.lhs b/compiler/types/OptCoercion.lhs
index 7eaab5c8a1de..d3dd2a4697a4 100644
--- a/compiler/types/OptCoercion.lhs
+++ b/compiler/types/OptCoercion.lhs
@@ -381,27 +381,28 @@ Note [Branched instance checking] in types/FamInstEnv.lhs.
\begin{code}
-- | Check to make sure that an AxInstCo is internally consistent.
--- Returns the number of the conflicting branch, if it exists
+-- Returns the conflicting branch, if it exists
-- See Note [Conflict checking with AxiomInstCo]
-checkAxInstCo :: Coercion -> Maybe Int
+checkAxInstCo :: Coercion -> Maybe CoAxBranch
-- defined here to avoid dependencies in Coercion
+-- If you edit this function, you may need to update the GHC formalism
+-- See Note [GHC Formalism] in CoreLint
checkAxInstCo (AxiomInstCo ax ind cos)
= let branch = coAxiomNthBranch ax ind
tvs = coAxBranchTyVars branch
+ incomps = coAxBranchIncomps branch
tys = map (pFst . coercionKind) cos
subst = zipOpenTvSubst tvs tys
lhs' = Type.substTys subst (coAxBranchLHS branch) in
- check_no_conflict lhs' (ind-1)
+ check_no_conflict lhs' incomps
where
- check_no_conflict :: [Type] -> Int -> Maybe Int
- check_no_conflict _ (-1) = Nothing
- check_no_conflict lhs' j
- | SurelyApart <- tcApartTys instanceBindFun lhs' lhsj
- = check_no_conflict lhs' (j-1)
+ check_no_conflict :: [Type] -> [CoAxBranch] -> Maybe CoAxBranch
+ check_no_conflict _ [] = Nothing
+ check_no_conflict lhs' (b@CoAxBranch { cab_lhs = lhs_incomp } : rest)
+ | SurelyApart <- tcApartTys instanceBindFun lhs' lhs_incomp
+ = check_no_conflict lhs' rest
| otherwise
- = Just j
- where
- (CoAxBranch { cab_lhs = lhsj }) = coAxiomNthBranch ax j
+ = Just b
checkAxInstCo _ = Nothing
-----------
diff --git a/compiler/types/TyCon.lhs b/compiler/types/TyCon.lhs
index bb95b795f133..fb078ec979a2 100644
--- a/compiler/types/TyCon.lhs
+++ b/compiler/types/TyCon.lhs
@@ -34,7 +34,7 @@ module TyCon(
isFunTyCon,
isPrimTyCon,
isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon,
- isSynTyCon, isOpenSynFamilyTyCon,
+ isSynTyCon,
isDecomposableTyCon,
isForeignTyCon,
isPromotedDataCon, isPromotedTyCon,
@@ -45,7 +45,9 @@ module TyCon(
isDataTyCon, isProductTyCon, isDataProductTyCon_maybe,
isEnumerationTyCon,
isNewTyCon, isAbstractTyCon,
- isFamilyTyCon, isSynFamilyTyCon, isDataFamilyTyCon,
+ isFamilyTyCon, isOpenFamilyTyCon,
+ isSynFamilyTyCon, isDataFamilyTyCon,
+ isOpenSynFamilyTyCon, isClosedSynFamilyTyCon_maybe,
isUnLiftedTyCon,
isGadtSyntaxTyCon, isDistinctTyCon, isDistinctAlgRhs,
isTyConAssoc, tyConAssoc_maybe,
@@ -137,17 +139,19 @@ Note [Type synonym families]
* Translation of type family decl:
type family F a :: *
translates to
- a SynTyCon 'F', whose SynTyConRhs is SynFamilyTyCon
+ a SynTyCon 'F', whose SynTyConRhs is OpenSynFamilyTyCon
-* Translation of type family decl:
- type family F a :: *
+ type family G a :: * where
+ G Int = Bool
+ G Bool = Char
+ G a = ()
translates to
- a SynTyCon 'F', whose SynTyConRhs is SynFamilyTyCon
+ a SynTyCon 'G', whose SynTyConRhs is ClosedSynFamilyTyCon, with the
+ appropriate CoAxiom representing the equations
* In the future we might want to support
- * closed type families (esp when we have proper kinds)
* injective type families (allow decomposition)
- but we don't at the moment [2010]
+ but we don't at the moment [2013]
Note [Data type families]
~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -369,7 +373,7 @@ data TyCon
tyConTyVars :: [TyVar], -- Bound tyvars
- synTcRhs :: SynTyConRhs Type, -- ^ Contains information about the
+ synTcRhs :: SynTyConRhs, -- ^ Contains information about the
-- expansion of the synonym
synTcParent :: TyConParent -- ^ Gives the family declaration 'TyCon'
@@ -577,18 +581,19 @@ isNoParent _ = False
--------------------
-- | Information pertaining to the expansion of a type synonym (@type@)
-data SynTyConRhs ty
+data SynTyConRhs
= -- | An ordinary type synonyn.
SynonymTyCon
- ty -- This 'Type' is the rhs, and may mention from 'tyConTyVars'.
+ Type -- This 'Type' is the rhs, and may mention from 'tyConTyVars'.
-- It acts as a template for the expansion when the 'TyCon'
-- is applied to some types.
- -- | A type synonym family e.g. @type family F x y :: * -> *@
- | SynFamilyTyCon {
- synf_open :: Bool, -- See Note [Closed type families]
- synf_injective :: Bool
- }
+ -- | An open type synonym family e.g. @type family F x y :: * -> *@
+ | OpenSynFamilyTyCon
+
+ -- | A closed type synonym family e.g. @type family F x where { F Int = Bool }@
+ | ClosedSynFamilyTyCon
+ (CoAxiom Branched) -- The one axiom for this family
\end{code}
Note [Closed type families]
@@ -596,8 +601,9 @@ Note [Closed type families]
* In an open type family you can add new instances later. This is the
usual case.
-* In a closed type family you can only put instnaces where the family
- is defined. GHC doesn't support syntax for this yet.
+* In a closed type family you can only put equations where the family
+ is defined.
+
Note [Promoted data constructors]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -970,7 +976,7 @@ mkPrimTyCon' name kind arity rep is_unlifted
}
-- | Create a type synonym 'TyCon'
-mkSynTyCon :: Name -> Kind -> [TyVar] -> SynTyConRhs Type -> TyConParent -> TyCon
+mkSynTyCon :: Name -> Kind -> [TyVar] -> SynTyConRhs -> TyConParent -> TyCon
mkSynTyCon name kind tyvars rhs parent
= SynTyCon {
tyConName = name,
@@ -1153,21 +1159,35 @@ isEnumerationTyCon (AlgTyCon {algTcRhs = DataTyCon { is_enum = res }}) = res
isEnumerationTyCon (TupleTyCon {tyConArity = arity}) = arity == 0
isEnumerationTyCon _ = False
--- | Is this a 'TyCon', synonym or otherwise, that may have further instances appear?
+-- | Is this a 'TyCon', synonym or otherwise, that defines a family?
isFamilyTyCon :: TyCon -> Bool
-isFamilyTyCon (SynTyCon {synTcRhs = SynFamilyTyCon {}}) = True
-isFamilyTyCon (AlgTyCon {algTcRhs = DataFamilyTyCon {}}) = True
+isFamilyTyCon (SynTyCon {synTcRhs = OpenSynFamilyTyCon }) = True
+isFamilyTyCon (SynTyCon {synTcRhs = ClosedSynFamilyTyCon {} }) = True
+isFamilyTyCon (AlgTyCon {algTcRhs = DataFamilyTyCon {}}) = True
isFamilyTyCon _ = False
+-- | Is this a 'TyCon', synonym or otherwise, that defines an family with
+-- instances?
+isOpenFamilyTyCon :: TyCon -> Bool
+isOpenFamilyTyCon (SynTyCon {synTcRhs = OpenSynFamilyTyCon }) = True
+isOpenFamilyTyCon (AlgTyCon {algTcRhs = DataFamilyTyCon }) = True
+isOpenFamilyTyCon _ = False
+
-- | Is this a synonym 'TyCon' that can have may have further instances appear?
isSynFamilyTyCon :: TyCon -> Bool
-isSynFamilyTyCon (SynTyCon {synTcRhs = SynFamilyTyCon {}}) = True
+isSynFamilyTyCon (SynTyCon {synTcRhs = OpenSynFamilyTyCon {}}) = True
+isSynFamilyTyCon (SynTyCon {synTcRhs = ClosedSynFamilyTyCon {}}) = True
isSynFamilyTyCon _ = False
isOpenSynFamilyTyCon :: TyCon -> Bool
-isOpenSynFamilyTyCon (SynTyCon {synTcRhs = SynFamilyTyCon { synf_open = is_open } }) = is_open
+isOpenSynFamilyTyCon (SynTyCon {synTcRhs = OpenSynFamilyTyCon }) = True
isOpenSynFamilyTyCon _ = False
+isClosedSynFamilyTyCon_maybe :: TyCon -> Maybe (CoAxiom Branched)
+isClosedSynFamilyTyCon_maybe
+ (SynTyCon {synTcRhs = ClosedSynFamilyTyCon ax}) = Just ax
+isClosedSynFamilyTyCon_maybe _ = Nothing
+
-- | Is this a synonym 'TyCon' that can have may have further instances appear?
isDataFamilyTyCon :: TyCon -> Bool
isDataFamilyTyCon (AlgTyCon {algTcRhs = DataFamilyTyCon {}}) = True
@@ -1427,7 +1447,7 @@ synTyConDefn_maybe (SynTyCon {tyConTyVars = tyvars, synTcRhs = SynonymTyCon ty})
synTyConDefn_maybe _ = Nothing
-- | Extract the information pertaining to the right hand side of a type synonym (@type@) declaration.
-synTyConRhs_maybe :: TyCon -> Maybe (SynTyConRhs Type)
+synTyConRhs_maybe :: TyCon -> Maybe SynTyConRhs
synTyConRhs_maybe (SynTyCon {synTcRhs = rhs}) = Just rhs
synTyConRhs_maybe _ = Nothing
\end{code}
@@ -1604,4 +1624,4 @@ checkRecTc (RC rec_nts) tc
| otherwise = Just (RC (addOneToNameSet rec_nts tc_name))
where
tc_name = tyConName tc
-\end{code}
\ No newline at end of file
+\end{code}
diff --git a/compiler/types/Unify.lhs b/compiler/types/Unify.lhs
index 67e748e777bf..34bc4b5ec40e 100644
--- a/compiler/types/Unify.lhs
+++ b/compiler/types/Unify.lhs
@@ -25,7 +25,7 @@ module Unify (
tcUnifyTys, BindFlag(..),
niFixTvSubst, niSubstTvSet,
- ApartResult(..), tcApartTys
+ UnifyResultM(..), UnifyResult, tcApartTys
) where
@@ -377,10 +377,10 @@ The workhorse function behind unification actually is testing for apartness,
not unification. (See [Apartness], above.) There are three
possibilities here:
- - two types might be NotApart, which means a substitution can be found between
+ - two types might be Unifiable, which means a substitution can be found between
them,
- Example: (Either a Int) and (Either Bool b) are NotApart, with
+ Example: (Either a Int) and (Either Bool b) are Unifiable, with
[a |-> Bool, b |-> Int]
- they might be MaybeApart, which means that we're not sure, but a substitution
@@ -393,7 +393,7 @@ possibilities here:
Example: (Either Int a) and (Either Bool b) are SurelyApart
-In the NotApart case, the apartness finding function also returns a
+In the Unifiable case, the apartness finding function also returns a
substitution, which we can then use to unify the types. It is necessary for
the unification algorithm to depend on the apartness algorithm, because
apartness is finer-grained than unification.
@@ -433,6 +433,41 @@ substituted, we can't properly unify the types. But, that skolem variable
may later be instantiated with a unifyable type. So, we return maybeApart
in these cases.
+Note [Apartness and the occurs check]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Are the types (x, x) and ([y], y) apart? The answer is "maybe". They clearly
+don't unify, but they also don't have a direct conflict. This is somewhere
+between unifiable and surely apart, so we use maybeApart.
+
+It turns out that this whole area is rather delicate, as regards soundness of
+type families. Specifically, we need to disallow the two instances
+
+ F x x = Int
+ F [y] y = Bool
+
+because if we have
+
+ Looper = [Looper]
+
+then the instances potentially overlap. A simple unification doesn't eliminate
+the overlap, so we use an apartness check with this special handling of the
+occurs check.
+
+Note [The substitution in MaybeApart]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The constructor MaybeApart carries data with it, typically a TvSubstEnv. Why?
+Because consider unifying these:
+
+(a, a, a) ~ (Int, F Bool, Bool)
+
+If we go left-to-right, we start with [a |-> Int]. Then, on the middle terms,
+we apply the subst we have so far and discover that Int is maybeApart from
+F Bool. But, we can't stop there! Because if we continue, we discover that
+Int is SurelyApart from Bool, and therefore the types are apart. This has
+practical consequences for the ability for closed type family applications
+to reduce. See test case indexed-types/should_compile/Overlap14.
+
+
\begin{code}
-- See Note [Unification and apartness]
tcUnifyTys :: (TyVar -> BindFlag)
@@ -442,18 +477,23 @@ tcUnifyTys :: (TyVar -> BindFlag)
-- second call to tcUnifyTys in FunDeps.checkClsFD
--
tcUnifyTys bind_fn tys1 tys2
- | NotApart subst <- tcApartTys bind_fn tys1 tys2
+ | Unifiable subst <- tcApartTys bind_fn tys1 tys2
= Just subst
| otherwise
= Nothing
-data ApartResult = NotApart TvSubst -- the subst that unifies the types
- | MaybeApart
- | SurelyApart
+-- This type does double-duty. It is used in the UM (unifier monad) and to
+-- return the final result.
+type UnifyResult = UnifyResultM TvSubst
+data UnifyResultM a = Unifiable a -- the subst that unifies the types
+ | MaybeApart a -- the subst has as much as we know
+ -- it must be part of an most general unifier
+ -- See Note [The substitution in MaybeApart]
+ | SurelyApart
tcApartTys :: (TyVar -> BindFlag)
-> [Type] -> [Type]
- -> ApartResult
+ -> UnifyResult
tcApartTys bind_fn tys1 tys2
= initUM bind_fn $
do { subst <- unifyList emptyTvSubstEnv tys1 tys2
@@ -527,13 +567,13 @@ unify subst ty1 ty2 | Just ty2' <- tcView ty2 = unify subst ty1 ty2'
unify subst (TyConApp tyc1 tys1) (TyConApp tyc2 tys2)
| tyc1 == tyc2 = unify_tys subst tys1 tys2
- | isSynFamilyTyCon tyc1 || isSynFamilyTyCon tyc2 = maybeApart
+ | isSynFamilyTyCon tyc1 || isSynFamilyTyCon tyc2 = maybeApart subst
-- See Note [Unifying with type families]
-unify _ (TyConApp tyc _) _
- | isSynFamilyTyCon tyc = maybeApart
-unify _ _ (TyConApp tyc _)
- | isSynFamilyTyCon tyc = maybeApart
+unify subst (TyConApp tyc _) _
+ | isSynFamilyTyCon tyc = maybeApart subst
+unify subst _ (TyConApp tyc _)
+ | isSynFamilyTyCon tyc = maybeApart subst
unify subst (FunTy ty1a ty1b) (FunTy ty2a ty2b)
= do { subst' <- unify subst ty1a ty2a
@@ -621,13 +661,14 @@ uUnrefined subst tv1 ty2 (TyVarTy tv2)
; b2 <- tvBindFlag tv2
; let ty1 = TyVarTy tv1
; case (b1, b2) of
- (Skolem, Skolem) -> maybeApart -- See Note [Apartness with skolems]
+ (Skolem, Skolem) -> maybeApart subst' -- See Note [Apartness with skolems]
(BindMe, _) -> return (extendVarEnv subst' tv1 ty2)
(_, BindMe) -> return (extendVarEnv subst' tv2 ty1) }
uUnrefined subst tv1 ty2 ty2' -- ty2 is not a type variable
| tv1 `elemVarSet` niSubstTvSet subst (tyVarsOfType ty2')
- = surelyApart -- Occurs check
+ = maybeApart subst -- Occurs check
+ -- See Note [Apartness and the occurs check]
| otherwise
= do { subst' <- unify subst k1 k2
; bindTv subst' tv1 ty2 } -- Bind tyvar to the synonym if poss
@@ -639,7 +680,7 @@ bindTv :: TvSubstEnv -> TyVar -> Type -> UM TvSubstEnv
bindTv subst tv ty -- ty is not a type variable
= do { b <- tvBindFlag tv
; case b of
- Skolem -> maybeApart -- See Note [Apartness with skolems]
+ Skolem -> maybeApart subst -- See Note [Apartness with skolems]
BindMe -> return $ extendVarEnv subst tv ty
}
\end{code}
@@ -666,33 +707,30 @@ data BindFlag
%************************************************************************
\begin{code}
-data UnifFailure = UFMaybeApart
- | UFSurelyApart
-
newtype UM a = UM { unUM :: (TyVar -> BindFlag)
- -> Either UnifFailure a }
+ -> UnifyResultM a }
instance Monad UM where
- return a = UM (\_tvs -> Right a)
- fail _ = UM (\_tvs -> Left UFSurelyApart) -- failed pattern match
+ return a = UM (\_tvs -> Unifiable a)
+ fail _ = UM (\_tvs -> SurelyApart) -- failed pattern match
m >>= k = UM (\tvs -> case unUM m tvs of
- Right v -> unUM (k v) tvs
- Left f -> Left f)
-
-initUM :: (TyVar -> BindFlag) -> UM TvSubst -> ApartResult
-initUM badtvs um
- = case unUM um badtvs of
- Right subst -> NotApart subst
- Left UFMaybeApart -> MaybeApart
- Left UFSurelyApart -> SurelyApart
+ Unifiable v -> unUM (k v) tvs
+ MaybeApart v ->
+ case unUM (k v) tvs of
+ Unifiable v' -> MaybeApart v'
+ other -> other
+ SurelyApart -> SurelyApart)
+
+initUM :: (TyVar -> BindFlag) -> UM TvSubst -> UnifyResult
+initUM badtvs um = unUM um badtvs
tvBindFlag :: TyVar -> UM BindFlag
-tvBindFlag tv = UM (\tv_fn -> Right (tv_fn tv))
+tvBindFlag tv = UM (\tv_fn -> Unifiable (tv_fn tv))
-maybeApart :: UM a
-maybeApart = UM (\_tv_fn -> Left UFMaybeApart)
+maybeApart :: TvSubstEnv -> UM TvSubstEnv
+maybeApart subst = UM (\_tv_fn -> MaybeApart subst)
surelyApart :: UM a
-surelyApart = UM (\_tv_fn -> Left UFSurelyApart)
+surelyApart = UM (\_tv_fn -> SurelyApart)
\end{code}
diff --git a/compiler/vectorise/Vectorise.hs b/compiler/vectorise/Vectorise.hs
index b939f4beb63a..012ae37039cf 100644
--- a/compiler/vectorise/Vectorise.hs
+++ b/compiler/vectorise/Vectorise.hs
@@ -27,7 +27,6 @@ import DynFlags
import Outputable
import Util ( zipLazy )
import MonadUtils
-import FamInstEnv ( toBranchedFamInst )
import Control.Monad
@@ -93,7 +92,7 @@ vectModule guts@(ModGuts { mg_tcs = tycons
-- and dfuns
, mg_binds = Rec tc_binds : (binds_top ++ binds_imp)
, mg_fam_inst_env = fam_inst_env
- , mg_fam_insts = fam_insts ++ (map toBranchedFamInst new_fam_insts)
+ , mg_fam_insts = fam_insts ++ new_fam_insts
}
}
diff --git a/compiler/vectorise/Vectorise/Env.hs b/compiler/vectorise/Vectorise/Env.hs
index 2d415aab36ad..3358ceafab1d 100644
--- a/compiler/vectorise/Vectorise/Env.hs
+++ b/compiler/vectorise/Vectorise/Env.hs
@@ -174,7 +174,7 @@ extendImportedVarsEnv ps genv
-- |Extend the list of type family instances.
--
-extendFamEnv :: [FamInst Unbranched] -> GlobalEnv -> GlobalEnv
+extendFamEnv :: [FamInst] -> GlobalEnv -> GlobalEnv
extendFamEnv new genv
= genv { global_fam_inst_env = (g_fam_inst, extendFamInstEnvList l_fam_inst new) }
where (g_fam_inst, l_fam_inst) = global_fam_inst_env genv
diff --git a/compiler/vectorise/Vectorise/Generic/PAMethods.hs b/compiler/vectorise/Vectorise/Generic/PAMethods.hs
index af815c92949d..9390696fc7ed 100644
--- a/compiler/vectorise/Vectorise/Generic/PAMethods.hs
+++ b/compiler/vectorise/Vectorise/Generic/PAMethods.hs
@@ -32,13 +32,13 @@ import Control.Monad
import Outputable
-buildPReprTyCon :: TyCon -> TyCon -> SumRepr -> VM (FamInst Unbranched)
+buildPReprTyCon :: TyCon -> TyCon -> SumRepr -> VM FamInst
buildPReprTyCon orig_tc vect_tc repr
= do name <- mkLocalisedName mkPReprTyConOcc (tyConName orig_tc)
rhs_ty <- sumReprType repr
prepr_tc <- builtin preprTyCon
let axiom = mkSingleCoAxiom name tyvars prepr_tc instTys rhs_ty
- liftDs $ newFamInst SynFamilyInst False axiom
+ liftDs $ newFamInst SynFamilyInst axiom
where
tyvars = tyConTyVars vect_tc
instTys = [mkTyConApp vect_tc . mkTyVarTys $ tyConTyVars vect_tc]
diff --git a/compiler/vectorise/Vectorise/Generic/PData.hs b/compiler/vectorise/Vectorise/Generic/PData.hs
index 893f1559beb7..6b06996ec8f0 100644
--- a/compiler/vectorise/Vectorise/Generic/PData.hs
+++ b/compiler/vectorise/Vectorise/Generic/PData.hs
@@ -14,7 +14,6 @@ import Vectorise.Generic.Description
import Vectorise.Utils
import Vectorise.Env( GlobalEnv( global_fam_inst_env ) )
-import Coercion( mkSingleCoAxiom )
import BasicTypes
import BuildTyCl
import DataCon
@@ -31,7 +30,7 @@ import Control.Monad
-- buildPDataTyCon ------------------------------------------------------------
-- | Build the PData instance tycon for a given type constructor.
-buildPDataTyCon :: TyCon -> TyCon -> SumRepr -> VM (FamInst Unbranched)
+buildPDataTyCon :: TyCon -> TyCon -> SumRepr -> VM FamInst
buildPDataTyCon orig_tc vect_tc repr
= fixV $ \fam_inst ->
do let repr_tc = dataFamInstRepTyCon fam_inst
@@ -42,7 +41,7 @@ buildPDataTyCon orig_tc vect_tc repr
where
orig_name = tyConName orig_tc
-buildDataFamInst :: Name -> TyCon -> TyCon -> AlgTyConRhs -> VM (FamInst Unbranched)
+buildDataFamInst :: Name -> TyCon -> TyCon -> AlgTyConRhs -> VM FamInst
buildDataFamInst name' fam_tc vect_tc rhs
= do { axiom_name <- mkDerivedName mkInstTyCoOcc name'
@@ -60,7 +59,7 @@ buildDataFamInst name' fam_tc vect_tc rhs
False -- Not promotable
False -- not GADT syntax
(FamInstTyCon ax fam_tc pat_tys)
- ; liftDs $ newFamInst (DataFamilyInst rep_tc) False ax }
+ ; liftDs $ newFamInst (DataFamilyInst rep_tc) ax }
where
tyvars = tyConTyVars vect_tc
rec_flag = boolToRecFlag (isRecursiveTyCon vect_tc)
@@ -92,7 +91,7 @@ buildPDataDataCon orig_name vect_tc repr_tc repr
-- buildPDatasTyCon -----------------------------------------------------------
-- | Build the PDatas instance tycon for a given type constructor.
-buildPDatasTyCon :: TyCon -> TyCon -> SumRepr -> VM (FamInst Unbranched)
+buildPDatasTyCon :: TyCon -> TyCon -> SumRepr -> VM FamInst
buildPDatasTyCon orig_tc vect_tc repr
= fixV $ \fam_inst ->
do let repr_tc = dataFamInstRepTyCon fam_inst
diff --git a/compiler/vectorise/Vectorise/Monad/InstEnv.hs b/compiler/vectorise/Vectorise/Monad/InstEnv.hs
index ceb62eef80ab..84b29ceb6119 100644
--- a/compiler/vectorise/Vectorise/Monad/InstEnv.hs
+++ b/compiler/vectorise/Vectorise/Monad/InstEnv.hs
@@ -67,7 +67,7 @@ lookupInst cls tys
--
lookupFamInst :: TyCon -> [Type] -> VM FamInstMatch
lookupFamInst tycon tys
- = ASSERT( isFamilyTyCon tycon )
+ = ASSERT( isOpenFamilyTyCon tycon )
do { instEnv <- readGEnv global_fam_inst_env
; case lookupFamInstEnv instEnv tycon tys of
[match] -> return match
diff --git a/compiler/vectorise/Vectorise/Type/Env.hs b/compiler/vectorise/Vectorise/Type/Env.hs
index 0ae0f936b398..66db6185da7b 100644
--- a/compiler/vectorise/Vectorise/Type/Env.hs
+++ b/compiler/vectorise/Vectorise/Type/Env.hs
@@ -162,7 +162,7 @@ vectTypeEnv :: [TyCon] -- Type constructors defined in this mo
-> [CoreVect] -- All 'VECTORISE [SCALAR] type' declarations in this module
-> [CoreVect] -- All 'VECTORISE class' declarations in this module
-> VM ( [TyCon] -- old TyCons ++ new TyCons
- , [FamInst Unbranched] -- New type family instances.
+ , [FamInst] -- New type family instances.
, [(Var, CoreExpr)]) -- New top level bindings.
vectTypeEnv tycons vectTypeDecls vectClassDecls
= do { traceVt "** vectTypeEnv" $ ppr tycons
diff --git a/compiler/vectorise/Vectorise/Utils/Base.hs b/compiler/vectorise/Vectorise/Utils/Base.hs
index d088f453553e..0bd54f4408d3 100644
--- a/compiler/vectorise/Vectorise/Utils/Base.hs
+++ b/compiler/vectorise/Vectorise/Utils/Base.hs
@@ -39,8 +39,6 @@ import DataCon
import MkId
import DynFlags
import FastString
-import Util
-import Panic
#include "HsVersions.h"
@@ -211,10 +209,8 @@ pdataReprTyCon :: Type -> VM (TyCon, [Type])
pdataReprTyCon ty
= do
{ FamInstMatch { fim_instance = famInst
- , fim_index = index
, fim_tys = tys } <- builtin pdataTyCon >>= (`lookupFamInst` [ty])
- ; ASSERT( index == 0 )
- return (dataFamInstRepTyCon famInst, tys)
+ ; return (dataFamInstRepTyCon famInst, tys)
}
-- |Get the representation tycon of the 'PData' data family for a given type constructor.
diff --git a/compiler/vectorise/Vectorise/Utils/PADict.hs b/compiler/vectorise/Vectorise/Utils/PADict.hs
index 8029dfb4662a..84a6ff37d912 100644
--- a/compiler/vectorise/Vectorise/Utils/PADict.hs
+++ b/compiler/vectorise/Vectorise/Utils/PADict.hs
@@ -119,7 +119,7 @@ prDictOfPReprInst :: Type -> VM CoreExpr
prDictOfPReprInst ty
= do
{ (FamInstMatch { fim_instance = prepr_fam, fim_tys = prepr_args }) <- preprSynTyCon ty
- ; prDictOfPReprInstTyCon ty (famInstAxiom (toUnbranchedFamInst prepr_fam)) prepr_args
+ ; prDictOfPReprInstTyCon ty (famInstAxiom prepr_fam) prepr_args
}
-- |Given a type @ty@, its PRepr synonym tycon and its type arguments,
diff --git a/docs/core-spec/CoreLint.ott b/docs/core-spec/CoreLint.ott
index beaf52a7d941..c452877ad5f7 100644
--- a/docs/core-spec/CoreLint.ott
+++ b/docs/core-spec/CoreLint.ott
@@ -229,7 +229,7 @@ forall </ ni // i />. (</ s1j // j /> ~> t1) = (</ axBranchkk // kk />)[ind]
</ substi @ // i /> = inits(</ [ ni |-> s'i ] // i />)
</ ni = zi_ki // i />
</ k'i <: substi(ki) // i />
-no_conflict(C, </ s2j // j />, ind-1)
+no_conflict(C, </ s2j // j />, ind, ind-1)
</ s2j = s1j </ [ni |-> s'i] // i/> // j />
t2 = t1 </ [ni |-> t'i] // i />
G |-ty t2 : k
@@ -403,16 +403,32 @@ Constraint <: *
------------------ :: LiftedConstraint
* <: Constraint
-defn no_conflict ( C , </ sj // j /> , ind ) :: :: check_no_conflict :: 'NoConflict_'
- {{ com Branched axiom conflict checking, \coderef{coreSyn/CoreLint.lhs}{lintCoercion\#check\_no\_conflict} }}
+defn no_conflict ( C , </ sj // j /> , ind1 , ind2 ) :: :: check_no_conflict :: 'NoConflict_'
+ {{ com \parbox{5in}{Branched axiom conflict checking, \coderef{types/OptCoercion.lhs}{checkAxInstCo} \\ and \coderef{types/FamInstEnv.lhs}{compatibleBranches} } }}
by
------------------------------------------------ :: NoBranch
-no_conflict(C, </ si // i/>, -1)
+no_conflict(C, </ si // i/>, ind, -1)
C = T </ axBranchkk // kk />
-forall </ ni // i />. (</ tj // j /> ~> t') = (</ axBranchkk // kk />)[ind]
+forall </ ni // i />. (</ tj // j /> ~> t') = (</ axBranchkk // kk />)[ind2]
apart(</ sj // j />, </ tj // j />)
-no_conflict(C, </ sj // j />, ind-1)
------------------------------------------------- :: Branch
-no_conflict(C, </ sj // j />, ind)
+no_conflict(C, </ sj // j />, ind1, ind2-1)
+------------------------------------------------ :: Incompat
+no_conflict(C, </ sj // j />, ind1, ind2)
+
+C = T </ axBranchkk // kk />
+forall </ ni // i />. (</ tj // j /> ~> s) = (</ axBranchkk // kk />)[ind1]
+forall </ n'i // i />. (</ t'j // j /> ~> s') = (</ axBranchkk // kk />)[ind2]
+apart(</ tj // j />, </ t'j // j />)
+no_conflict(C, </ sj // j />, ind1, ind2-1)
+------------------------------------------- :: CompatApart
+no_conflict(C, </ sj // j />, ind1, ind2)
+
+C = T </ axBranchkk // kk />
+forall </ ni // i />. (</ tj // j /> ~> s) = (</ axBranchkk // kk />)[ind1]
+forall </ n'i // i />. (</ t'j // j /> ~> s') = (</ axBranchkk // kk />)[ind2]
+unify(</ tj // j />, </ t'j // j />) = subst
+subst(s) = subst(s')
+----------------------------------------- :: CompatCoincident
+no_conflict(C, </ sj // j />, ind1, ind2)
\ No newline at end of file
diff --git a/docs/core-spec/CoreSyn.ott b/docs/core-spec/CoreSyn.ott
index 4c59849bb665..ca27b8b34c30 100644
--- a/docs/core-spec/CoreSyn.ott
+++ b/docs/core-spec/CoreSyn.ott
@@ -117,7 +117,7 @@ LorR :: 'LeftOrRight_' ::= {{ com left or right deconstructor, \coderef{types/Co
C :: 'CoAxiom_' ::= {{ com Axioms, \coderef{types/TyCon.lhs}{CoAxiom} }}
| T </ axBranchi // ; // i /> :: :: CoAxiom {{ com Axiom }}
- | ( C ) :: M :: Parens {{ com Parentheses }}
+ | ( C ) :: M :: Parens {{ com Parentheses }}
axBranch, b :: 'CoAxBranch_' ::= {{ com Axiom branches, \coderef{types/TyCon.lhs}{CoAxBranch} }}
| forall </ ni // i /> . ( </ tj // j /> ~> s ) :: :: CoAxBranch {{ com Axiom branch }}
@@ -229,6 +229,7 @@ terminals :: 'terminals_' ::=
| Constraint :: :: Constraint {{ tex \textsf{Constraint} }}
| no_conflict :: :: no_conflict {{ tex \textsf{no\_conflict} }}
| apart :: :: apart {{ tex \textsf{apart} }}
+ | unify :: :: unify {{ tex \textsf{unify} }}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Formulae %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -270,6 +271,7 @@ formula :: 'formula_' ::=
| axBranch1 = axBranch2 :: :: branch_rewrite
| C1 = C2 :: :: axiom_rewrite
| apart ( </ ti // i /> , </ sj // j /> ) :: :: apart
+ | unify ( </ ti // i /> , </ sj // j /> ) = subst :: :: unify
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Subrules and Parsing %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
diff --git a/docs/core-spec/Makefile b/docs/core-spec/Makefile
index 9449a0e1af6a..3dfed54e157a 100644
--- a/docs/core-spec/Makefile
+++ b/docs/core-spec/Makefile
@@ -5,6 +5,7 @@ TARGET = core-spec
$(TARGET).pdf: $(TARGET).tex $(OTT_TEX)
latex -output-format=pdf $<
+ latex -output-format=pdf $<
$(TARGET).tex: $(TARGET).mng $(OTT_FILES)
ott $(OTT_OPTS) -tex_filter $< $@ $(OTT_FILES)
diff --git a/docs/core-spec/core-spec.mng b/docs/core-spec/core-spec.mng
index 4b1e986c6ddb..10ed4f7e9f3d 100644
--- a/docs/core-spec/core-spec.mng
+++ b/docs/core-spec/core-spec.mng
@@ -150,6 +150,12 @@ Axioms:
\ottaxBranch
}
+The definition for $[[axBranch]]$ above does not include the list of
+incompatible branches (field \texttt{cab\_incomps} of \texttt{CoAxBranch}),
+as that would unduly clutter this presentation. Instead, as the list
+of incompatible branches can be computed at any time, it is checked for
+in the judgment $[[no_conflict]]$. See Section~\ref{sec:no_conflict}.
+
\subsection{Type constructors}
Type constructors in GHC contain \emph{lots} of information. We leave most of it out
@@ -306,10 +312,14 @@ There are two very similar checks for names, one declared as a local function:
\ottdefnisSubKind{}
\subsection{Branched axiom conflict checking}
+\label{sec:no_conflict}
The following judgment is used within \ottdrulename{Co\_AxiomInstCo} to make
sure that a type family application cannot unify with any previous branch
-in the axiom.
+in the axiom. The actual code scans through only those branches that are
+flagged as incompatible. These branches are stored directly in the
+$[[axBranch]]$. However, it is cleaner in this presentation to simply
+check for compatibility here.
\ottdefncheckXXnoXXconflict{}
@@ -318,4 +328,7 @@ It checks to see if \coderef{types/Unify.lhs}{tcApartTys} returns \texttt{Surely
Two types are apart if neither type is a type family application and if they do not
unify.
+The algorithm $[[unify]]$ is implemented in \coderef{types/Unify.lhs}{tcUnifyTys}.
+It performs a standard unification, returning a substitution upon success.
+
\end{document}
diff --git a/docs/core-spec/core-spec.pdf b/docs/core-spec/core-spec.pdf
index be13ca22c55086aeed35641ebc27deea5f847af4..21de3642a3db3ee805c56b2545b0d7a963bfe9ea 100644
GIT binary patch
delta 98108
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�>r&p#SWk>CPNOF_jO12+=ZAxajUpYwW
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≺w1#FrflAGgqofDWPYZ&K%eIL16a&CPcd?+?P9
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
Y-NV|=gR%7js*%B`fYz^9*`dnuKc55fEC2ui
delta 72092
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�>LLS4Bg*#Vl%#)F*`XUJQ|0ck1SNir
zu$B`0{7LLxUZI{!BZV6BfhDe!$_MRAq@`|g&3n-0GLk~bI~!j#Th=+d`Y@Jw)CN}D
zZzZy)MPhZocZToV56{c7`h@UBiNMQ^pW1seoiPK_p;q!rva0yIw=X==&cba7hf8LE
zphP{B3gsU<K9R(L=mZbxC%kIxOwBYbRb-5v<KHWEYiwRcCJvaY$h&Y~D8EybDDFHr
zzC<D}^2kT%@9F0MlGRQ8a6}Lrcs7A;m{SPmyV8Ui!5f^c-WzWUL2AYGT^PC?Qp(R0
zk=Vot)qm#45<DlrxHQVR=pm4NpdGz`jgZ-z`7Mw6y@qGgAS;%DKb4BOT67cn8%E-i
zQEcY}`<Z~jCa?bTQGf>u7~-3ruvdi@4{1cue2bj`AExR>VWJ76$hX-nM4xfJ<U7>K
z*{jRP?cDDlW{?9Wbag*3VyIRGPFD0_+}PTn3=N}=)Qd=O5N%4gB?T9OfOn67DA!)q
zpO_Ll4Z|E6kE6VsMkq=Y9VFu^sjpZ_NkPZib)=ohdE;?ZTFM69dZA;{4zP2bzh&tR
zZ{0n8$y9>3$cUHJ&U~*2jGf8fbq<!8yhNmJ{$8nFPorVnivIO!ZR*3L*Fry+BAyz~
zjh6jd4q31}Ue7DElO>!DXcldMnKx8qM_%*DFMG2p-{5Dy%Y^FUW4!kEl=$;-?^$DH
zE;<&p;5D<QtOH!YaVzufypO4l#Y8c$mQhzfcW)?|Eom*QS~NS10Xg8JL5SKG*z=8>
zAc=6fw}yH}*9|yTaeIxgK#aOuV0|}&@faRrmLey`KM~=TO(rRTE?~2Nx>ilhCFA^}
zAbDCHOpOCi^?lW73orSXY^IMX@ormpR7i7=8g*dVA=PyCf*E|L(<y1w13DnDB?r(`
ztJcQ9v6)Q?f{L!v>t!c&lY5`sG(P(^)|XOZ<Srx!uV4oAfPXo~HSx>=Ql4h~1QF<>
zjCZ-JwwvSt#Cy?bJlw&5IqN%IRrDCRGS_goz21NCFfhx<5|Y_?n@&XywuQ?@Cs$4B
zF?MyfB2UK5i{l*GtVut&Az(+<)-VnLYYQ<F2pbz8R&G8{Rj}x;FJhOvOVPppsw!wn
zglGw;8oiC9xPzoCocnrS4Z7@WhAx9<ieGWu_Tqo|nD(8(n^pgRcf>1w_TT~EDU>3g
zAERM>mv=mRi^|fB__D6Er!jMsx@Vt38~ad|6}<uv;-z5MLooK*EVyREp95>98OK8i
z*xB_ex|`|n1*Wiw1#D>jg(dSu84hNy@J^C;2h-UEo^g#vCld?y9C%r`h*ObC6Z45#
z9t)?cou0Y+q(CKqu}@2YX}^jq31+gy%tV4tfqV)nEsq1TYjcInu>k5lF;c2cbL0;k
zt;G1U#_HUyCVF#hD-i3K$@k#{e2$$Bk$h5&v8D_Z9*7edLN1<}hqdTrde0T7TyASn
za9@K0_3}t{*#=Q%qi;9J4&wVFSB!W@pLdDf&QthjM__S(i(B_uU1NX84N{3NUMGOj
zgf4(<va&>LBXRmZPc=iYQHfbCdc}5D1N+4V==W3`;$=S;-jRqd<JJ&_|3<`~0wvqU
z2kID3f~6*cV*7I}7L@5TC8$40k)7>uCB&F(QBQ>x$u~0a*BU}UM>9~)CymBhCo!Fh
z7H)L8HbEVKgmih>`(g2Jy_4H%icdnHQnwQ~+m|}O6xD3*xnqBS6tsg(2{FvcfJ8`{
zRrmsn?U6%Wold~t=|cUKHp3r#m$@eUD;KsFrb_g-eNxStI0^x2OK2>vFLYrntz1^V
z$zL+>ds4xUR4c;IbFZrN4-ldf{0<MeQSN+TnZ|*Cc%8ulY^>o4I)sqe_#Ue`d&RmB
z3_Vabs1pi35&9GYVQPC#zskSJ)V^#9G&!xNGUT>jrX5Deeh^KBBi^Kb2VkQ6Tnhr>
zU(f2zyl+23ZlFBL{+*O0-VXx`*@NtwzUL=?Ab!$|V2x1|al?Ls<VM&av|en&e-4(P
zg32s^Wl+i)t(62ss&@LRIMlwoXmi~!Ye8?ALqkgobzJ=Q^)pF0W_vAGB|*qqh=n00
zb%tgNb{hXj57uqcddsf@M(@62C*oL)EnE_wF~1N^IRv4oXMT9^d|5#y#rA6nsk#*#
z$e;%rDnIuxzl`_ul6uE&51HF+_<Jo}qzILN&>KxF?C5JsHMyG?3aO=zFmIPd(|{sR
zf8p|DvG@70ohHO*b%x?Zu?5Al5oy+(Xwh?m?E`2wX{t*|MOhM+=CN|~ncI8Kk)|&=
zcfAQ!+34?&1&X(shtT!k&&oF_hufd<>DevOJdL!%s18iC4Ih3^*kSWWyXrLV`Ha1P
zOc-QLpisIU+-Rg-+jS||V-m1$LKhrN`<c+4`XdGS;9h{ed0SLXd$jIwuV71W9`0JL
z*d0)<L{dvEYpYG}bDe8QjLxp2pt~ZY3gxX;Hz)(1aTD&(_-tuUZCt&$SfGW<b4xN9
zOA8ysb+BC=T_EGpsI(IpU^%5Hr>F>ji+u0|Z@mzh(7C&(B{GWZXO)r9FX`dyk(yYx
zuR+pIFSiG-?ZUjQ(8T#%!A9dmSL?41puRixzF3^=xKY^QczTF`9Z08E(^0>KzL@4y
z2)n3YJ1g`p=>AD{a?&Sknw%5Fe~i<dZa_wC+tFyOpDruRzQJ5_v4b)kSsTQEmHJKd
z9VX<5J(_GLXhWWT_Rf>hh4oVISoJ}K3~tI!GTl$7<Y&Gd<e0i~kk%Dml4)9M`V_#g
zEX@h}FK9LXEnBtN99s+q?jr)oKfCXYu}40rWxK>#J-ADp{?Z4+9Os$V$WB-E?>(tY
zZdcYbDo~7>Bz)$MSuiyfG=(~Uu^Og>#u_0?=p}RjVkS@o*cTAw%E^dS7@Du$FwAYO
z^$;tz%(i09Pxp3AY#Mc<y5Aw8!QGr3K1arB>{}h5h>LL&e<v)q`1;avP=Rq@2G{1b
z$UdGj)pCpf{_|otTUO4T-o&%}D4|vA*D3GP=;n2Ri-3m#fz(D3%=*=Tm6pExSS^oL
zbbF509$QWRHxyV7Y^Q2@<=_1NSW!ao5pkX<oRX)C(4kBz6F$>C^Y0|1ST`qI^Xe<3
z=gfM&H?~5?C*8cJ<+Kr!u}}v|Ss=Nl)n=Z^QAAk;Ylg5~LIerkrD!5sd862SD1q|_
zWJd9`z5x%iXLwP!5g3Vo*91yO8V9&;G+9G4KR(~zm3BU?<inTg0TgOOdRj+KK1G7?
zn<>`@2_Gg^3Jrx0@A7|<ALwdqCE7i{bjvTjivlEUQdD@LK|0G)JQijw>WABjIiKhs
zj);6!Sf#o)*&}F6{_vT(HumW^h#pQ1T&0hnDp+T3h#pU1(ty!_RVNgVKq5f!sd1;^
zhkxArLc;jfO&_5_OF-YY=T7`7_ELGCFFl4L(-!u(EWKC~JTw+oELmwT4B|<yb5rp$
z$S^m*2>u^zH0lDOOqnPT*Mb*|3}=nYgs|qn2EQ<Kj4<!)Iv*jqIG>RaRW>2%MHGnM
z9u*3X;LKXe3V|$t=QujvdAe>9xshojeO7h=7~bl-VPMe_6qKmgw{<4L?&J{(-%KW>
z3{gpSG!jA|Ce!v7R{Q$(j2+g?KoKy^M*Rx0J8W8n)>c!c<NdPyVu?Be{{^~j|8{^`
zl!zhn4B0{D)%{b=@*`@4)HTX4A1u>=ezAn&9lDL=O!@qO6B&}6YI0AZLmld15y<Fl
z_4l7)IEfub6XjMmMG<k0%4}Uq4$%ZA>0kR%FF;Uc6e&&pdZ^EA>*$#FgPBY82WdcQ
zMk$=V??=G;x;xwUnUC>j?6|iN2Z-Q0ij8}cu$?wwB3K*1CPrYMD;O)?gL7Dl$YtDf
z9wenl)jJV?ou^I97u-p7?k{Zawn($*I6wa>0%}D0J>hpPFunznMl^1Ts`ovwBj+w3
z5?EE$W1)E;(YM2)1kP>(Z+SzI%fdQIMHMTG)~$+CsCrMZYpbsIV+L%0;KeVC6C2uP
zb|RriR-SdCC&yoWoy~eVecT`#_q-_-10VAZ>G@HAG2b&nrc}jh0=(!sRT7O+{-_a0
zJLe>jv-JJA_6syc^c-Nv)>4#WnI2O?(rn92&Tk`+E1HS-J>P2^NPu^tT!NN=8fU&<
zxbsrtF?El5acpv#`x~L_{Ja>98hyk8zCQ{~jeEqpzbNZ>0LceC%!nu~g){H?OPM-p
z#H<E?XHniOErWdJTG)9KYaRCt%Fg&szH7d%mrZkC%}A%yT!-^&zyQN4dlH}f-2L}X
zPi7RA)PVS1)X&^IKUseu-;Sj!^UzE?P&Zm=dX+Zk|DfuDwrys@L{C1B=7LQ$m>~3d
zOwMm=a8%kFxtU{EDjZBohJ!*Gk3lkkQCkszB;wp-q=1foFWIqfe1ez2W2X0bYL_;d
z>@gECxHI-q^_1+}5X8=VV~5c##jPK*ar5Pa^u6}K9n(v&!Y}0^g<A#XV1ibDJ5%-+
zD=P1@hHGrSYNu_9VdEo1uzgQYZZt*?udum{t!MV<J4jV<-JJI*AUUd|70fSha@JOV
zp@O20fwK&on3?u4Y1S#irP!C>n&|k<ogtaZjG#&O^`O^}t^cy}I8h6Nd?HWdc{``G
zD!jOD<-*Vo{s2-hnnQf}BP3@RWnm#+!cPNDLcJ;s*27E5kQSMQ<>f7xf+1Qk%BUwB
zR~D9$eOUWSYfJ9+FA~cd@iTjTZ*BX36AM^iV=eySujpn7O-_^x6|YJRcHfc){^ZvB
zzB3c<_N(hAiruOJ?mY$8VrFv>q`T!6qmJKReV_($0E&W_1lh~)AJtYqG<0xu%sFfU
z-!ak#P}?yGxBE+uXTJN^i9I@+AgP9?CB3KH-}@n$PV<rM-E<MQyI9V>ZsBQv#+t0V
z@{JHXk@#x9MAXzxjUTk=1G&5y_^99`Tczw5=`Sv&5*v@w{lM@{Y;_p*Ro06a5;*mC
z`GrX>1%j<vcvxs6o5RW<{_GnlqKrD?J5#Bfu7sbpU*0wR(AhrLFmJ+lpeW$hOIR}f
z(bL<Te<j|UKaTQ|{lMs&mRmP}obiqoD;>cdh>sCqjvk8y$8Z9Y_8as;hWrr?VNW@(
zJmWJv>j_7q0>_!BwR>A4mn)s<fy}8=oOm=Yvjbszt2)%97?!do>Vh;;>Y$egtWH5w
z$iXwQD3jGBT_>J!&d|e{eOXFHqD13tyvvfy5zJh5GI5J}44-(n{SlFW>fU3fl<4CF
zrk@-eYHHv?*c2<iEl*e~+hfy0x-E_(5lB{N7uHA#V`ni2B0RCPw>#%7L#iDdUtmmU
zU#*YLywp9=<PQad<`DsX_De_98}CrI=$y8O3V-0|S+_ri4ksC2EzAoDA?Y-gNRClC
zxZl%gGBb^En0j?-n{|AD<$dL4%@TaP4cCo1O5_qZR;vYjKam&g2XT)=e%y1@!}KZr
zhJ)&F?f3$rHe%0Nsy3DK*va9-APWZs!WlG8*<QLU4q)Vzr6^p=`CKoXdbQm;FG`1A
zuE)VV%{(b1XQUOxF%W<MG^EAdmDJxNsxI$yrecuYSDw0=U&<YSXAYwR?;PoU@W*Ti
zCH)|7Ke1Ij8PTjLoU$DP)bJM<h441?9lFL4ughexoi)&(6Gp1AI0Ef{{`R#_7=pX=
zt59mqL#&PDim<A^w6Kah>fdwrLlBb6EqYN2#zPLp$u8rMOYw+R{lIts*yh8?V#@Ue
zr}*PLvd24;GRofwo16a+pt?!9m%)qz6PK7l1QoY`egxGH0yH_7!HohHw_c6}pB<M-
zjszCB5Um6T9GCj61SPi^$^`Hmm-ER47q|T81Q!XH<>mwww($hK2bTy51rj7rVro-#
zZ3-_=ATcm73NJ=!a&vSbI5sj0FHB`_XLM*FH8U}nVT=JOf9+gZZ`;V0e)q57;|wlh
z*1iCZ3nX3=JF%1YlI1q?pg4-H+p^`B<nHwS^>db@SR_S9i+ctGG+-5r#oEqy);g4>
z3Q@=+ibAPE3tK2z=;)zZSRV=%3+F|lZ4oS7Oc4!q3x$+W*S?TSxgBVdM#jR(LRu*c
zV+-k(FN`T<f57%wD4|SYU_L2bVRfOj(S=ooGBCA;=ML7i@Z5*E<1{P}TXDD}Xm_sA
zTB^cX*nu#Gi-mSD-UZkKjQ7w#LT9fEBdjUBEsQe0@D8q4?|9gXa<Tw=;2H}LTY`m(
zAPS?Q2(V=jbO(jkSOg7Q7SL|+3jJV<h)IC0Tj6&Ce{9uZzW^BF6+n`(X#mj$Ws4}`
zs^K2Cq=C4oVM_w829}bdh=8VXaCI<+mpd?ZG_c7CxC$X*V1$a+SORmP0H6hcE1l9%
z1Gr^`!4j~L$^hk3z@2gdCxDL@8hgW74J_S}fSuG9$dM90+DDoTm?rRvgb~KzSOp^h
z0gY^he_Dh+!u-fok56HQ)c}@MaAzH^0b(L;l(2?|5l#X`C>hcji%;RsIe<^1$avb3
zfsfY`C_=IE7MLngP<+6-42%eZ1PVq3O(F&D!8*SqL11JE0`>=7mXUC=Fd~9jK@CPk
z12tfQ1bF}ff~$v(;F>W24Je2xS=K{EA^{dff799>Y(QDSdkeT4xH?n<m`-?H#6cy1
z=l~!JSc02JamK}<58#CCf{OM?5mc;@J3sxjQ(pXeKP<|3gX`f=xi`6+5AWu)LWA0!
z?UZN3+2mn*HJpJCQp3sc>uB&|^1b*)K!XGR_^3Yb!0;)IgDp_EfButZK7`qdpMEOJ
ze?y?d;1jHZl%^`+<x({izG?)4uDXKarz)t26jdDsrK$rls_KryQ?(<Ds&*8DR0pw_
z)tZ_xN~<ChsSbND-%Tf1=fipN3*fSUSd<sT@AKkwMb=WlR0lD&9c0UKsBu~eg$y;1
zl98Gn%3vZKjaxMo3|}=p=#bh95G^}^f5hzosikFOKr&D>JaP<j$N(f=%>v|Ty%ip=
zjfXZ*B_NwiMT7k{syXF3?wKa#!m_|}Q*2@f8--nER1{pdrelysLWz-(keC669zx2Y
zVUSLBNC^RH7zxRjL0TFax*0%3N<wN#Ndf7QZiZ4W-~GP3)?N3{{kQi%&pzkR^W&^%
zowJ`?Lk#AzMEb8jy#26yEe*7q^#Wm-p4ZCmTD=(N%hRO_yr-_H>%2iCZb>O=Etce_
zdk`B-#U_3`HiTF?f94UCN-&I<uo9{EstM7bFsSq!USK7SedR2D{*VBnN?KBLU(cC*
z8bFtVwI(s6vWxI>Z8Yk<PgvrzB<6BaaitI<(v^n~r!J#>UjcI1dP#XB@RxQ(Gxj3^
z=S&&0+s2zB+)`a}&zs<ip=PQ>k$&Jl2s^q@ZzQMT%9B#Xm9l?lP#Z9BSB=D)YzUaw
z*d0%xcjp8!Cv1JY-c&CgqcX1B?k}0UuK6pUuPe<7w0&i4+WU0M7WcN?u_EoEhPAR^
zs(>2@2_@||xxp1GQTm}rkqd>jx?k%ope<rlC}ltn)K9Gm*$;|vAs#bxU1ulVWO})_
znQa|<+)P!izo+&^gZ8wlNCSD=T+<Bn1`nx78Ymv%CG+uBCN#^ZJg?rZJ#sQGlu_7E
z{!%f~TzhDxD8ex>Y`4Vu&xv?tniJDF%7ba#Zf2Z}0$u5OD9+rf>G;{wvYTd!A4lG!
zh|CGuQ38srS5-_c1siIR!)Mi!JZVWBqYE3JDK-ulCVlzxy+FTvD;p^~L2X;}pmF<N
z16)CfjBb1NcWI%w+XvSDq*+IjDp~gLo<05&!i2a|b3DV!%WWuX*+74bOiK8q*uW;0
zHg=-SeMm7+)ctMzSF#MBcZCU3_KnGjk=Q9giJ-%xStp(d)y8Cl$g3Z>-6Wd#Ixv?7
z;QF5%s*1vTmwmv>59`QD<_`%UH24d?4+lQ#!e^x{U6XGq%!4I24Mr_BpouI6TPFE9
zG-yaU`-+kT>+$D8ct1zU137GiDLA!TjtfAvnx%1}n%rYiz=e;SYL%U-WM2vV6`!u(
z1DkuWq}yapJ$(T4V<<D#IY<;$9({USQ&C|`_|NCOkBaG|HI!9IXLWR)w`>1ggQ8qM
zPr46XVUqvG$veZnl~@uAn%{j>L!qi~1%cd=rBoY$d@WItskw=a(@e8$_t;bi!Y$r7
zi_;DE9_N{aTEhpJ%nJr1)PqX|+g|2&M^_ue@eJN=Sz^G%h!=?4!~dwFSY=x=2k%om
z_LhUkLlDq{7JY{-$S^F6nl0{7zTg;KLt9GyoLG@_d;+6y$m?El=8CtA;y5I*@ZhzQ
zs@{agseE4%J?qbLa?XS1x@3wjK1_>dRth0WneXflaPP%%X12<H5dz(#rDXidlj*<x
zZg1)X+V~mTv!rY+>8McN(JtfBWLUR;H@6i}r6y0f3T6zsq-8;qKtI7FOsh@LOJ#RP
zf-7x(be~GOkcheth2Y;A3HnF8``Z_rmw%JVS7cIvDQjCt07j<YM>*fb$wG^xbk$-W
zfvEHu)W2oL$YrYmEfvjw7e3yQ^5B04D<Gr&rCHAz2g&G^!(cRnT)#TRm3XAf;#>v-
zb<W%SW$oW0d5Jk+)3z?rw0^Tvd`KreAy_@Sm=`b6|I_S{<Tuy1Nwb1!W%rl|eU?NS
zr%Qbep*tPKv>8hv&U4`6l3~lIJi$DQqli!^H;3TvDZkzD_zpLz_o7KD+H3c8JLT|v
zsOL#C4xh{RC+IUEGz8vu$Vn31f3Qv?^;m9BAo}k_2J&57Tp^@fvLIzPMfE#eDXFE;
zE55`38T5F;!l{_=OK-MAr(h-iH+*qGko0t^MfYccSlc~L|4Qfb<T!V)GutOx8Ke`H
zQ*t+ZUR4Lu=T;9wjPYhB#A0`)T{r2_`p%bH9r{UJel+|&x`@yHUV1Ui<x)F*!Dy**
zcvgXw2~y=!9k#NXTDc;T)64(E=f;(c=;f#?Ip*$7<=3b=vP50?oKWa&j*_EKj8>_N
zCq1D^VUn+tfz%@KEi7Hh?)T}m(34Y$Qg@*SFAYWHR=WbSpLFy&1+nEBT2ysp61vV5
z__%G!;)hcB``IzuoD)hfFC6|l>9u3zu`T>O1lgU_*0B2HWJ2xb`0i{%ZT+hc4#B&T
z)=o?H>Tj|6#`LpQ2%6DXFz&jqcJED2muO3$PkJ8q%R1unC2^x(bQ1|1T=*loqWBiY
zi8{1<6H%NB`HYO{Keq2RW4`MlricQFLZ$7r41Tg;g+0jL4vq6a(a$O^9@1imq8H|(
z>5&KdPjoc@0pwn?Ks4T)4$u~A#gyQ(?11yql8oO}cx$=C$1N-*9rhCuI?-U!XmPh!
znX_P5r;ukx*xxU#OiVp_tL=ZNR!XN)W<Fi8tx%t8ZJJO?FPbnf)DX|v&PrUBNnwT?
zFgUQ;w+0GH62R%yxF#Rx=Yq3>>N19ZQXy-LE<w~J59qYFU7-8q8{F;TF3jnNO#_&x
zTrUDq#xZu@r^y%*fzc}HonKfcN)(H+V5|J4H=C-;Z-fqbg$?;TrKudrs!R9u=pm0Z
z*rop`mv(}fzh?||Yp^4c9;#Xqih^n-b(})B3gh?{q8tqVg7s8J`r$f>0t1HJNPd+H
z&p)dewfA)aM*7KW{N`v!HIK81i!4rw19}cfe;q!{MleG!xoAh?VA*%FP>kT~D*o~n
zN|>q5&ii`(1=UCG%G`g@>^YF|9?xI!&S4phd<y}tKvXU9xT0|22PUho%AJiTeaDX?
zID}r|j7_0(?if5%CP=E#jhtmd;;<X=5>vIqpOLz_NeA^yDP`9o8ukh51`2oBc@i7b
zmMccbNF3dwlU)dmr#l&R?Yb6Bc$3vmRX)oO{6T@oFRD9dRDz=D(>}G{CHRZt`&$+j
zYOI4{>3`u_x>bmh@EY)pIsS;%tanYtEpJT>Rfh$hu@(TdQ<K$-&z+F28aSeKqqPN#
z>HwbHq_aLdlL_|4WdTG6c#cIM@3TcA-9fq$2e>QocYzqxA3sW;$W)d_VpK!d=($=x
zh)AjFK`{REq2dVJp$TKZ$*du@%#SAm!3aE(MV4(Qa%HKyHz}GZWjc}?9h90*0wg(2
zZ;<yZ=Kjz{Y$autx*)RYebdub#-Pil+Aq|~euQvbzWqNm)1?JyVmmHA>F8TxJ$niX
z!8fVft87ICVC)Nnej%%e8j?n=$3_0w2sb?DVC_~=4t_9&HrM?varcZDu)yJyqdxIQ
zx<J9IjUKCu@BWYGS9*FzfnQ9^58NN1h1$7cko)~EB01w^PF+YF;nAQEj=T9x3gaR0
zhyj~s#tVUnot_9G%^Y44C=WaMTTSU2W4IOkcLWQ8zaL2zV;vcT4EX@{6ODd--8hlv
zj!vvNVcYqeQ#YX-xgiZS9I7{<1@ITzg?l$;h#1hMHkw2(o1s)1a~cl^)xIR>ly48f
z{S|hSdOT$PvXS9&#%n$fujP5qI_^O?wxkOr-i~}rXXp&uHVhta6AM{%o#7a+Dnegh
zz8YBcmSUUlOp3)C=UQ>xygXR@uFk*I;p+~4au4ULWS!${XL+Rci8qPrmPI{qfj@Vo
z>hK8zO~!6=K-jf$*Vx$*t7nfak8s#X4lK}DoZ}yL;}PURRc{wTkwPxD+afw)kzb)m
zY01n6mD$12K6_}rp4TD}x!&kuh{85|80cV4rA0XYX8L$Zh58kYUP?*^t1QnkaiCBN
zqVLNhpT;q)WV*2BMm(hr;19HF<HHSv9V7e<+0&}AlIt)(v$iKA*w|y}=q)kL1%P>U
z>3Ht95Axkhi{MN-E$q&5QOo7YUprsYiyHvhF9J0mbn_!TNXT(p3x|$+Qg!(3>kHY_
z%(ynf;FHWPca!1UkIB^Q2kRW`xZ{yyg|4jv@^VYkDPxg%s>L<}6WlP)pIbeHTdMQ=
zafQ)mn@LDTJ}JCf^jX91)34Nd>;xrb`~?1LACOiOihtCYr<Szw>bPIr)1;?uPtD5?
zo<SZ_(MU^g!+9zNRJ1Na^0s=3_E=VM$|fYM*AIa~Qly0$^9xi1JNT*3{#1uuUn@zo
z&j()u(w1Kv!G>RZQCe<<MS94yQM%Xi>--AmsUpNiQm3VjEYb^l^9#)K>eWZ<5@|5B
z<{@d;DLo1-BD1D@(|Xg2RZ!N$uT0Z5MRKFEfC2rb=}k)(NnaXXuV06Sout_-&YR{E
zJ=BNQ%*2>dG<d(^X$UrL<6aJGFzitH5Q9vostRTs?(K3rDbwks_=<$E=<X*nPV~IJ
znCr5!plY`c;e6+KL4ri93+}gPO5paF&yiSnK+WRh22;D)vmJPxv2Mnh`Q==fy97sv
z{EXZp%GbEzQ%)RdU8cO}FUX9CP*{-f@%iEA%N3XShZ7OMZ0;>Pnm7lTHtRB`UxHut
zxsiAAC;Z}hE2MdIbNP4Vc9z#5z{}8?an%9nFa8E$;6hz$v{?|7H33arFb0-~X(92{
zVTt?wm*T%r7T7lVb~*X$DBAh-y;}8@0jHxoW4?;+>CtLTlg@ksnIs?FIenH|-Tpej
z?Sp7zmgsZ+$CpS<W9m#^06(EeMnMI_L?nJB{yZ86B`6i(jk+!W!%%RMl3qXIF!{Iy
z9qR<G^E^C0#6#!TjiO^*X?bFbk)P(z41yJ{Rym2o8zd5!H~VT(6dYn3ZwF@#EgMp^
zue@q*SB`0Fq><yBZrNsi-;Fr`3RVG`f4?4UI{!W_6o{!)^RS?Hk($E1iex%i2=tG3
z&%$*kgqAaduY9{*SN8-kbnMc_dqOYb8o429UNYLpqIdIpj{?+%Pt76@kgGdgx*Q6$
zG*FGz*M;IJ4=r;-+8Zu)kJNWN>`vy%RS2dL`5dT1m&4T!oCB*Aku#=iyyRx#>*j2r
z#3m72tbKcghm!MSHeJMAQ5TK(bKDR)m%fo8eg5%}zwF1wWNQ*QKt3`Sl&q__o)&rJ
zO9tNb^`&?iUg9a<b!)?dR3eHY1))@XlXk`?Z2~3JjVJr-TiE7DHj<9Ly>Or>2NBbR
z_c%@0O-K_~mc62i8|TKDB|ylJ3rZ!@8`^U7N`a7U${uaCN<<H}e4Ff7smE$U)MDQn
z6k;#193=6d_2uz1U$;MM&qcXr{xzva_*v(+UU_-L)=slm6uUT)8{v0%NhRp}nKSbR
zt&CIv^_Y2WBMfKu`21%5Xsnq&?>b*W-Ij^HS8nWb^1W5(Q8-S(^yjSDW@!cz_i^T6
z9r-}<<DCWN+({TZHi%$Foi^P=L5k`Vy{VA#xX7q+^bfnD?-dBG_z~;e;BUZ_m3-U<
zmAK<gL@lX+g<2vqnKJRvTPe}NX}l{SJ3;o5q?syX{QBC1&Fzd;Y9H%QXHKGQM)oU@
z4V}~LBzxT!*;r`}q3nzeimOi;1Nmth)wXG;s5i)?XtPP{YRb|Fz|N*$!dmOFNXwhm
zwVO*=JSco6{mlcYM9`z>n*>!J4=V2~=#0p(z}tgal7gC%EL3e6>CBKiLitXFSF8AU
zhbfE`ul;86!ASJf`Y<e1cvaz@MtplXk7b_&C1tQ#-BW=p+TQMDh(oP2OVN1O33{A9
zAJJsn>Dy;^r6h6%0jG@9J*<~%Bv@QAtFJ(OunO|^^z|pHZ;{#xY9jKtTVmC12Qodk
zL&Q1zWqv^x(a2=epL~V&`rFS;D_D1K1xd8CY2EIkiKrcDDpp2P$v?`k0f@I###dap
z#yBlGpk)eS=PsaLh8Ia?>=gLp(7^O@A&E{o5t6z`f3TjL#5ROPSK2aH_S;=!UJ|{N
zv1BhU?LN42Kc12Qr)}8H?jpe7xq2a3dfMt&gK-*C#@e#~`}W10zq81qU-YDvLj81a
z*2a&sE)s0xB6EXLTE24YpfMBV{0-r7qt#$Nlkwj7ls?AZ%=*uZ?+z*(`Su!y(9V)%
zX*(hd{@5|A7B0`YhOsVV=iakvSH$w1v(Fl3{7U-gbgc!+yp|MZx5}#S)pE&tZI>E<
zF8D9Iy9PHIV@PKI97&BNynnAyb|pgRO|AHXA?u=Ie`e|8`H%fKWn$NukO)c7>bqr3
z1YOhoXP0-rvW-8@EPW6|XBF&wB*~2i(R-7V1HnA5Howd+o6lDi+)FQ4D1@##RE74`
z{w=RY0*EQo`T@jD_@Zgc0Ae1nC|DE(0fWWFK~h2>2rmf4%MTFIc6+5_>xBUFsmO?e
z{tqNgl7d)6OjKA*2rMiP5(bL``3w;zcatZ)5x_ezm>=luZtLaXiLeEFBRo7E-CThZ
z!go0Sw8cXr76C&)cLY%6e~Gh_|D(-<Mejl_gsZ)m!<{w@0j7Zmi1?7%DcWwCiZl@i
zH!)4uc-O7Z^b5LsC_g`<T9R^{By_3hHZWILq`JhhdBYz*%plU~+8rE5`*?dlx+nL6
zi0r=NeZBoKk|HTR^3D@?HtvWh5*{)Tz|0npN$wtiJX~*EFU~KE@TKC%(~uSUea$66
z)TlgPg$RU%hlGLinf3%S$76VyRWcxG;hpTSKc%daL6`b0jaJ;Kfb_IX83I?2Gz;z{
z2i8Jdx2M+CEBIf*&m)snCAB479cM23Mytgwcv@y_Zj0SXsOANELtUPW!B;uCxOb#J
zSWqU*m)|x!aEWP3-@TUFl;0ycymv$R2Wp;Y4z<E1*3~<IvRC;bk-k?5Mq#dSdt2ja
zX=tJ5&w|z0yK`07<JIH9!N(B`JlVOOLG9$ckz&(?SMr*hM=~YLrp2dI-@tFUvsnwM
z9d2HDx88fIJk54^-pzKFT@rSRA4J{LzwIm$^CPxI^Q*%UtMj*?%Y%@;5mcghn>J<h
zY8m;J@Rj=*NeQYL>By`eF%NbLMJ85UB~?$wI%WYcG0lsW`tTwB@@ypK-RD&8P04Z?
zNT7Vt?`Sr9`anm<c?tHgeUL-4a24evLe}-ja^pKm`?hsRsm!8$^5GEc6FujT_Hi{m
zOC9o%#Yl$D&oqC1oVY$hrjn+Tj?vqv$jL&Xf*JMuWQ*l24FpXXSy=Dz8>{tp?|76@
zt^JE(>+US>@&D#CQbG&}0=m6$0?Nq&ME=b!69a@DKm_Lc3gHVh2LZtn;+6mrxT8Pf
zUm-xm7-$X#iUGlQMFTfCue&1nZVQ8db=bMxWupJdRDkAkDq`Z&s*)-a5K%E@X)!QJ
zT3SU(2?ADCl9G~CgMh^4!NC6?b9c~xSS=0#{fE^&Kbm!u^jUk37Cna(G@G7V87eY3
z)^alHGYCaJttIm%ES+cIOY46BUi(EpxTiyvUcCqvUf9!p`%Tq{jnyK{3-U%xDYqEQ
zyXfhMbX;h(v%4M^BmjSeFgr)fao4SNAY*bMx>NlRa8xwVS|!GQfa$stai<PMH@0DZ
z91lraev`)wSd-T!e8b%XrHUgEY^$<=0;9y4=o440H;@=637EXl#Y*P~fK9Gy&$pim
zRUnPg^{;_vHLqdDsr^cHk=k}%)iDk?1kum91arqr7bYM5AbL{oG(hXYe9l*mpm2<E
zN!gtA^h>Vq{LJfB7{|)h3zL;rl6e-&4MXxu!wl9Kwm6GnlG4gQ3L>+3TGv>mb+7t}
zJrYinG}lCT{frd&2<M)(C*sdkKb{1B2+aRV@Q+A&#Jf2C$>&R|m!}U7TW>fcLjEK>
z5ec7}r@Y7dP4ZdT!rrp&|Kxp6RdxCtLV|l~{+6(9qtJ=9tx*SpuW)S$A#XoZeM|rP
z?~wJR(8Wk>+1#PRc$q9&ztW^-c$>~7L+6C#q<H5B$0Rh|7(98e(>w^n7k}vbj3fRw
z?FH+n<U1QGjy;YK<2nHVgzGC$FAs#R%fF&K3IaU6Y(2buJ?_{i29lJ3fB`%_s=8``
F{{p6y=tKYj
diff --git a/docs/users_guide/glasgow_exts.xml b/docs/users_guide/glasgow_exts.xml
index d9ad6a57875b..710efbb1ece5 100644
--- a/docs/users_guide/glasgow_exts.xml
+++ b/docs/users_guide/glasgow_exts.xml
@@ -4872,7 +4872,7 @@ representation).</para>
<title>Type families</title>
<para>
- <firstterm>Indexed type families</firstterm> are a new GHC extension to
+ <firstterm>Indexed type families</firstterm> form an extension to
facilitate type-level
programming. Type families are a generalisation of <firstterm>associated
data types</firstterm>
@@ -4915,11 +4915,11 @@ representation).</para>
indices.
</para>
<para>
- Indexed type families come in two flavours: <firstterm>data
- families</firstterm> and <firstterm>type synonym
- families</firstterm>. They are the indexed family variants of algebraic
- data types and type synonyms, respectively. The instances of data families
- can be data types and newtypes.
+ Indexed type families come in three flavours: <firstterm>data
+ families</firstterm>, <firstterm>open type synonym families</firstterm>, and
+ <firstterm>closed type synonym families</firstterm>. They are the indexed
+ family variants of algebraic data types and type synonyms, respectively. The
+ instances of data families can be data types and newtypes.
</para>
<para>
Type families are enabled by the flag <option>-XTypeFamilies</option>.
@@ -5027,7 +5027,7 @@ data instance G [a] b where
</para>
<para>
- Even if type families are defined as toplevel declarations, functions
+ Even if data families are defined as toplevel declarations, functions
that perform different computations for different family instances may still
need to be defined as methods of type classes. In particular, the
following is not possible:
@@ -5073,22 +5073,24 @@ instance Foo Char where
<title>Synonym families</title>
<para>
- Type families appear in two flavours: (1) they can be defined on the
- toplevel or (2) they can appear inside type classes (in which case they
- are known as associated type synonyms). The former is the more general
- variant, as it lacks the requirement for the type-indexes to coincide with
- the class parameters. However, the latter can lead to more clearly
- structured code and compiler warnings if some type instances were -
- possibly accidentally - omitted. In the following, we always discuss the
- general toplevel form first and then cover the additional constraints
- placed on associated types.
+ Type families appear in three flavours: (1) they can be defined as open
+ families on the toplevel, (2) they can be defined as closed families on
+ the toplevel, or (3) they can appear inside type classes (in which case
+ they are known as associated type synonyms). Toplevel families are more
+ general, as they lack the requirement for the type-indexes to coincide
+ with the class parameters. However, associated type synonyms can lead to
+ more clearly structured code and compiler warnings if some type instances
+ were - possibly accidentally - omitted. In the following, we always
+ discuss the general toplevel forms first and then cover the additional
+ constraints placed on associated types. Note that closed associated type
+ synonyms do not exist.
</para>
<sect3 id="type-family-declarations">
<title>Type family declarations</title>
<para>
- Indexed type families are introduced by a signature, such as
+ Open indexed type families are introduced by a signature, such as
<programlisting>
type family Elem c :: *
</programlisting>
@@ -5124,12 +5126,7 @@ F Bool -- WRONG: unsaturated application
<sect3 id="type-instance-declarations">
<title>Type instance declarations</title>
<para>
- There are two forms of type family instance declaration: unbranched and
- branched. Branched instances list any number of alternatives, to be
- checked in order from top to bottom, similarly to normal function
- declarations. Unbranched instances supply only one left-hand side.
-
- Unbranched instance declarations of type families are very similar to
+ Instance declarations of type families are very similar to
standard type synonym declarations. The only two differences are that
the keyword <literal>type</literal> is followed by
<literal>instance</literal> and that some or all of the type arguments
@@ -5145,45 +5142,55 @@ type instance Elem [e] = e
</para>
<para>
- Branched instance declarations, on the other hand, allow many different
- left-hand-side type patterns. These patterns are tried in order, from
- top to bottom, when simplifying a type family application. A branched instance
- declaration is introduced by <literal>type instance where</literal>. For example:
+ Type family instance declarations are only legitimate when an
+ appropriate family declaration is in scope - just like class instances
+ require the class declaration to be visible. Moreover, each instance
+ declaration has to conform to the kind determined by its family
+ declaration, and the number of type parameters in an instance
+ declaration must match the number of type parameters in the family
+ declaration. Finally, the right-hand side of a type instance must be a
+ monotype (i.e., it may not include foralls) and after the expansion of
+ all saturated vanilla type synonyms, no synonyms, except family synonyms
+ may remain.
+ </para>
+ </sect3>
+
+ <sect3 id="closed-type-families">
+ <title>Closed type families</title>
+ <para>
+ A type family can also be declared with a <literal>where</literal> clause,
+ defining the full set of equations for that family. For example:
<programlisting>
-type instance where
+type family F a where
F Int = Double
F Bool = Char
F a = String
</programlisting>
- In this example, we declare an instance for <literal>F</literal> such
- that <literal>F Int</literal> simplifies to <literal>Double</literal>,
- <literal>F Bool</literal> simplifies to <literal>Char</literal>, and for
- any other type <literal>a</literal> that is known not to be
- <literal>Int</literal> or <literal>Bool</literal>, <literal>F
- a</literal> simplifies to <literal>String</literal>. Note that GHC must
- be sure that <literal>a</literal> cannot unify with
- <literal>Int</literal> or <literal>Bool</literal> in that last case; if
- a programmer specifies just <literal>F a</literal> in their code, GHC will
- not be able to simplify the type. After all, <literal>a</literal> might later
- be instantiated with <literal>Int</literal>.
+ A closed type family's equations are tried in order, from top to bottom,
+ when simplifying a type family application. In this example, we declare
+ an instance for <literal>F</literal> such that <literal>F Int</literal>
+ simplifies to <literal>Double</literal>, <literal>F Bool</literal>
+ simplifies to <literal>Char</literal>, and for any other type
+ <literal>a</literal> that is known not to be <literal>Int</literal> or
+ <literal>Bool</literal>, <literal>F a</literal> simplifies to
+ <literal>String</literal>. Note that GHC must be sure that
+ <literal>a</literal> cannot unify with <literal>Int</literal> or
+ <literal>Bool</literal> in that last case; if a programmer specifies
+ just <literal>F a</literal> in their code, GHC will not be able to
+ simplify the type. After all, <literal>a</literal> might later be
+ instantiated with <literal>Int</literal>.
</para>
<para>
- Branched instances and unbranched instances may be mixed freely for the same
- type family.
+ A closed type family's equations have the same restrictions as the
+ equations for an open type family instances.
</para>
+ </sect3>
+ <sect3 id="type-family-examples">
+ <title>Type family examples</title>
<para>
- Type family instance declarations are only legitimate when an
- appropriate family declaration is in scope - just like class instances
- require the class declaration to be visible. Moreover, each instance
- declaration has to conform to the kind determined by its family
- declaration, and the number of type parameters in an instance
- declaration must match the number of type parameters in the family
- declaration. Finally, the right-hand side of a type instance must be a
- monotype (i.e., it may not include foralls) and after the expansion of
- all saturated vanilla type synonyms, no synonyms, except family synonyms
- may remain. Here are some examples of admissible and illegal type
+Here are some examples of admissible and illegal type
instances:
<programlisting>
type family F a :: *
@@ -5192,13 +5199,11 @@ type instance F String = Char -- OK!
type instance F (F a) = a -- WRONG: type parameter mentions a type family
type instance F (forall a. (a, b)) = b -- WRONG: a forall type appears in a type parameter
type instance F Float = forall a.a -- WRONG: right-hand side may not be a forall type
-type instance where -- OK!
- F (Maybe Int) = Int
- F (Maybe Bool) = Bool
- F (Maybe a) = String
-type instance where -- WRONG: conflicts with earlier instances (see below)
- F Int = Float
- F a = [a]
+type family H a where -- OK!
+ H Int = Int
+ H Bool = Bool
+ H a = String
+type instance H Char = Char -- WRONG: cannot have instances of closed family
type family G a b :: * -> *
type instance G Int = (,) -- WRONG: must be two type parameters
@@ -5207,35 +5212,83 @@ type instance G Int Char Float = Double -- WRONG: must be two type parameters
</para>
</sect3>
<sect3 id="type-family-overlap">
- <title>Overlap of type synonym instances</title>
+ <title>Compatibility and apartness of type family equations</title>
<para>
- The unbranched instance declarations of a type family used in a single
- program may only overlap if the right-hand sides of the overlapping
- instances coincide for the overlapping types. More formally, two
- instance declarations overlap if there is a substitution that makes
- the left-hand sides of the instances syntactically the same. Whenever
- that is the case, if the instances are unbranched, the right-hand
- sides of the instances must also be syntactically equal under the same
- substitution. This condition is independent of whether the type family
- is associated or not, and it is not only a matter of consistency, but
- one of type safety. Branched instances are not permitted to overlap
- with any other instances, branched or unbranched.
+ There must be some restrictions on the equations of type families, lest
+ we define an ambiguous rewrite system. So, equations of open type families
+ are restricted to be <firstterm>compatible</firstterm>. Two type patterns
+ are compatible if
+<orderedlist>
+<listitem><para>all corresponding types in the patterns are <firstterm>apart</firstterm>, or</para></listitem>
+<listitem><para>the two patterns unify producing a substitution, and the right-hand sides are equal under that substitution.</para></listitem>
+</orderedlist>
+ Two types are considered <firstterm>apart</firstterm> if, for all possible
+ substitutions, the types cannot reduce to a common reduct.
</para>
+
<para>
- Here are two example to illustrate the condition under which overlap
- is permitted.
+ The first clause of "compatible" is the more straightforward one. It says
+ that the patterns of two distinct type family instances cannot overlap.
+ For example, the following is disallowed:
+<programlisting>
+type instance F Int = Bool
+type instance F Int = Char
+</programlisting>
+ The second clause is a little more interesting. It says that two
+ overlapping type family instances are allowed if the right-hand
+ sides coincide in the region of overlap. Some examples help here:
<programlisting>
type instance F (a, Int) = [a]
type instance F (Int, b) = [b] -- overlap permitted
type instance G (a, Int) = [a]
type instance G (Char, a) = [a] -- ILLEGAL overlap, as [Char] /= [Int]
-
-type instance H Int = Int
-type instance where -- ILLEGAL overlap, as branched instances may not overlap
- H a = a
</programlisting>
- </para>
+ Note that this compatibility condition is independent of whether the type family
+ is associated or not, and it is not only a matter of consistency, but
+ one of type safety. </para>
+
+ <para>
+ The definition for "compatible" uses a notion of "apart", whose definition
+ in turn relies on type family reduction. This condition of "apartness", as
+ stated, is impossible to check, so we use this conservative approximation:
+ two types are considered to be apart when the two types cannot be unified,
+ even by a potentially infinite unifier. Allowing the unifier to be infinite
+ disallows the following pair of instances:
+<programlisting>
+type instance H x x = Int
+type instance H [x] x = Bool
+</programlisting>
+ The type patterns in this pair equal if <literal>x</literal> is replaced
+ by an infinite nesting of lists. Rejecting instances such as these is
+ necessary for type soundness.
+ </para>
+
+ <para>
+ Compatibility also affects closed type families. When simplifying an
+ application of a closed type family, GHC will select an equation only
+ when it is sure that no incompatible previous equation will ever apply.
+ Here are some examples:
+<programlisting>
+type family F a where
+ F Int = Bool
+ F a = Char
+
+type family G a where
+ G Int = Int
+ G a = a
+</programlisting>
+ In the definition for <literal>F</literal>, the two equations are
+ incompatible -- their patterns are not apart, and yet their
+ right-hand sides do not coincide. Thus, before GHC selects the
+ second equation, it must be sure that the first can never apply. So,
+ the type <literal>F a</literal> does not simplify; only a type such
+ as <literal>F Double</literal> will simplify to
+ <literal>Char</literal>. In <literal>G</literal>, on the other hand,
+ the two equations are compatible. Thus, GHC can ignore the first
+ equation when looking at the second. So, <literal>G a</literal> will
+ simplify to <literal>a</literal>.</para>
+
<para> However see <xref linkend="ghci-decls"/> for the overlap rules in GHCi.</para>
</sect3>
@@ -5366,10 +5419,6 @@ instance GMapKey Flob where
the free indexed parameter is of a kind with a finite number of alternatives
(unlike <literal>*</literal>).
</para>
-
- <para>
- Branched associated type instances are not currently supported.
- </para>
</sect3>
<sect3 id="assoc-decl-defs">
diff --git a/ghc/InteractiveUI.hs b/ghc/InteractiveUI.hs
index 7aaa1f157103..4ff822f03b98 100644
--- a/ghc/InteractiveUI.hs
+++ b/ghc/InteractiveUI.hs
@@ -1047,7 +1047,7 @@ filterOutChildren get_thing xs
Nothing -> False
pprInfo :: PrintExplicitForalls
- -> (TyThing, Fixity, [GHC.ClsInst], [GHC.FamInst GHC.Branched]) -> SDoc
+ -> (TyThing, Fixity, [GHC.ClsInst], [GHC.FamInst]) -> SDoc
pprInfo pefas (thing, fixity, cls_insts, fam_insts)
= pprTyThingInContextLoc pefas thing
$$ show_fixity
@@ -2215,7 +2215,7 @@ showBindings = do
return $ maybe (text "") (pprTT pefas) mb_stuff
pprTT :: PrintExplicitForalls
- -> (TyThing, Fixity, [GHC.ClsInst], [GHC.FamInst GHC.Branched]) -> SDoc
+ -> (TyThing, Fixity, [GHC.ClsInst], [GHC.FamInst]) -> SDoc
pprTT pefas (thing, fixity, _cls_insts, _fam_insts) =
pprTyThing pefas thing
$$ show_fixity
--
GitLab