Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Typechecking class declarations
Synopsis
- tcClassSigs :: Name -> [LSig GhcRn] -> LHsBinds GhcRn -> TcM [TcMethInfo]
- tcClassDecl2 :: LTyClDecl GhcRn -> TcM (LHsBinds GhcTc)
- findMethodBind :: Name -> LHsBinds GhcRn -> TcPragEnv -> Maybe (LHsBind GhcRn, SrcSpan, [LSig GhcRn])
- instantiateMethod :: Class -> TcId -> [TcType] -> TcType
- tcClassMinimalDef :: Name -> [LSig GhcRn] -> [TcMethInfo] -> TcM ClassMinimalDef
- type HsSigFun = Name -> Maybe (LHsSigType GhcRn)
- mkHsSigFun :: [LSig GhcRn] -> HsSigFun
- instDeclCtxt1 :: LHsSigType GhcRn -> SDoc
- instDeclCtxt2 :: Type -> SDoc
- instDeclCtxt3 :: Class -> [Type] -> SDoc
- tcATDefault :: SrcSpan -> Subst -> NameSet -> ClassATItem -> TcM [FamInst]
- substATBndrs :: Subst -> [TyVar] -> (Subst, [Type])
Documentation
tcClassSigs :: Name -> [LSig GhcRn] -> LHsBinds GhcRn -> TcM [TcMethInfo] Source #
findMethodBind :: Name -> LHsBinds GhcRn -> TcPragEnv -> Maybe (LHsBind GhcRn, SrcSpan, [LSig GhcRn]) Source #
tcClassMinimalDef :: Name -> [LSig GhcRn] -> [TcMethInfo] -> TcM ClassMinimalDef Source #
instDeclCtxt1 :: LHsSigType GhcRn -> SDoc Source #
instDeclCtxt2 :: Type -> SDoc Source #
tcATDefault :: SrcSpan -> Subst -> NameSet -> ClassATItem -> TcM [FamInst] Source #
Construct default instances for any associated types that aren't given a user definition Returns [] or singleton
substATBndrs :: Subst -> [TyVar] -> (Subst, [Type]) Source #
Apply a substitution to the type variable binders of an associated type
family. This is used to compute default instances for associated type
families (see tcATDefault
) as well as newtype
-derived associated type
family instances (see gen_Newtype_fam_insts
in GHC.Tc.Deriv.Generate).
As a concrete example, consider the following class and associated type family:
class C k (a :: k) where
type F k a (b :: k) :: Type
type F j p q = (Proxy j p, Proxy
j (q :: j))
If a user defines this instance:
instance C (Type -> Type) Maybe where {}
Then in order to typecheck the default F
instance, we must apply the
substitution [k :-> (Type -> Type), a :-> Maybe]
to F
's binders, which
are [k, a, (b :: k)]
. The result should look like this:
type F (Type -> Type) Maybe (b :: Type -> Type) =
(Proxy (Type -> Type) Maybe, Proxy
(Type -> Type) (b :: Type -> Type))
Making this work requires some care. There are two cases:
- If we encounter a type variable in the domain of the substitution (e.g.,
k
ora
), then we apply the substitution directly. - Otherwise, we substitute into the type variable's kind (e.g., turn
b :: k
tob :: Type -> Type
). We then return an extended substitution where the oldb
(of kindk
) maps to the newb
(of kindType -> Type
).
This step is important to do in case there are later occurrences of b
,
which we must ensure have the correct kind. Otherwise, we might end up
with Proxy @(Type -> Type) (b :: k)
on the right-hand side of the
default instance, which would be completely wrong.
Contrast substATBndrs
function with similar substitution functions:
substTyVars
does not substitute into the kinds of each type variable, nor does it extend the substitution.substTyVars
is meant for occurrences of type variables, whereassubstATBndr
s is meant for binders.substTyVarBndrs
does substitute into kinds and extends the substitution, but it does not apply the substitution to the variables themselves. As such,substTyVarBndrs
returns a list ofTyVar
s rather than a list ofType
s.