| Safe Haskell | Safe-Inferred | 
|---|---|
| Language | Haskell2010 | 
GHC.Tc.TyCl.Class
Description
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
- badMethodErr :: Outputable a => a -> Name -> TcRnMessage
- instDeclCtxt1 :: LHsSigType GhcRn -> SDoc
- instDeclCtxt2 :: Type -> SDoc
- instDeclCtxt3 :: Class -> [Type] -> SDoc
- tcATDefault :: SrcSpan -> TCvSubst -> NameSet -> ClassATItem -> TcM [FamInst]
- substATBndrs :: TCvSubst -> [TyVar] -> (TCvSubst, [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 #
badMethodErr :: Outputable a => a -> Name -> TcRnMessage Source #
instDeclCtxt1 :: LHsSigType GhcRn -> SDoc Source #
instDeclCtxt2 :: Type -> SDoc Source #
tcATDefault :: SrcSpan -> TCvSubst -> NameSet -> ClassATItem -> TcM [FamInst] Source #
Construct default instances for any associated types that aren't given a user definition Returns [] or singleton
substATBndrs :: TCvSubst -> [TyVar] -> (TCvSubst, [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.,
    kora), then we apply the substitution directly.
- Otherwise, we substitute into the type variable's kind (e.g., turn
    b :: ktob :: 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:
- substTyVarsdoes not substitute into the kinds of each type variable, nor does it extend the substitution.- substTyVarsis meant for occurrences of type variables, whereas- substATBndrs is meant for binders.
- substTyVarBndrsdoes substitute into kinds and extends the substitution, but it does not apply the substitution to the variables themselves. As such,- substTyVarBndrsreturns a list of- TyVars rather than a list of- Types.