Safe Haskell | None |
---|---|
Language | Haskell2010 |
GHC.Hs.Types
Synopsis
- data HsType pass
- = HsForAllTy {
- hst_xforall :: XForAllTy pass
- hst_fvf :: ForallVisFlag
- hst_bndrs :: [LHsTyVarBndr pass]
- hst_body :: LHsType pass
- | HsQualTy { }
- | HsTyVar (XTyVar pass) PromotionFlag (Located (IdP pass))
- | HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)
- | HsAppKindTy (XAppKindTy pass) (LHsType pass) (LHsKind pass)
- | HsFunTy (XFunTy pass) (LHsType pass) (LHsType pass)
- | HsListTy (XListTy pass) (LHsType pass)
- | HsTupleTy (XTupleTy pass) HsTupleSort [LHsType pass]
- | HsSumTy (XSumTy pass) [LHsType pass]
- | HsOpTy (XOpTy pass) (LHsType pass) (Located (IdP pass)) (LHsType pass)
- | HsParTy (XParTy pass) (LHsType pass)
- | HsIParamTy (XIParamTy pass) (Located HsIPName) (LHsType pass)
- | HsStarTy (XStarTy pass) Bool
- | HsKindSig (XKindSig pass) (LHsType pass) (LHsKind pass)
- | HsSpliceTy (XSpliceTy pass) (HsSplice pass)
- | HsDocTy (XDocTy pass) (LHsType pass) LHsDocString
- | HsBangTy (XBangTy pass) HsSrcBang (LHsType pass)
- | HsRecTy (XRecTy pass) [LConDeclField pass]
- | HsExplicitListTy (XExplicitListTy pass) PromotionFlag [LHsType pass]
- | HsExplicitTupleTy (XExplicitTupleTy pass) [LHsType pass]
- | HsTyLit (XTyLit pass) HsTyLit
- | HsWildCardTy (XWildCardTy pass)
- | XHsType (XXType pass)
- = HsForAllTy {
- data NewHsTypeX = NHsCoreTy Type
- type LHsType pass = Located (HsType pass)
- type HsKind pass = HsType pass
- type LHsKind pass = Located (HsKind pass)
- data HsTyVarBndr pass
- = UserTyVar (XUserTyVar pass) (Located (IdP pass))
- | KindedTyVar (XKindedTyVar pass) (Located (IdP pass)) (LHsKind pass)
- | XTyVarBndr (XXTyVarBndr pass)
- type LHsTyVarBndr pass = Located (HsTyVarBndr pass)
- data ForallVisFlag
- data LHsQTyVars pass
- = HsQTvs {
- hsq_ext :: XHsQTvs pass
- hsq_explicit :: [LHsTyVarBndr pass]
- | XLHsQTyVars (XXLHsQTyVars pass)
- = HsQTvs {
- data HsImplicitBndrs pass thing
- = HsIB { }
- | XHsImplicitBndrs (XXHsImplicitBndrs pass thing)
- data HsWildCardBndrs pass thing
- = HsWC { }
- | XHsWildCardBndrs (XXHsWildCardBndrs pass thing)
- type LHsSigType pass = HsImplicitBndrs pass (LHsType pass)
- type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass)
- type LHsWcType pass = HsWildCardBndrs pass (LHsType pass)
- data HsTupleSort
- type HsContext pass = [LHsType pass]
- type LHsContext pass = Located (HsContext pass)
- noLHsContext :: LHsContext pass
- data HsTyLit
- newtype HsIPName = HsIPName FastString
- hsIPNameFS :: HsIPName -> FastString
- data HsArg tm ty
- numVisibleArgs :: [HsArg tm ty] -> Arity
- type LHsTypeArg p = HsArg (LHsType p) (LHsKind p)
- type LBangType pass = Located (BangType pass)
- type BangType pass = HsType pass
- data HsSrcBang = HsSrcBang SourceText SrcUnpackedness SrcStrictness
- data HsImplBang
- data SrcStrictness
- data SrcUnpackedness
- getBangType :: LHsType a -> LHsType a
- getBangStrictness :: LHsType a -> HsSrcBang
- data ConDeclField pass
- = ConDeclField {
- cd_fld_ext :: XConDeclField pass
- cd_fld_names :: [LFieldOcc pass]
- cd_fld_type :: LBangType pass
- cd_fld_doc :: Maybe LHsDocString
- | XConDeclField (XXConDeclField pass)
- = ConDeclField {
- type LConDeclField pass = Located (ConDeclField pass)
- pprConDeclFields :: OutputableBndrId p => [LConDeclField (GhcPass p)] -> SDoc
- data HsConDetails arg rec
- data FieldOcc pass
- = FieldOcc {
- extFieldOcc :: XCFieldOcc pass
- rdrNameFieldOcc :: Located RdrName
- | XFieldOcc (XXFieldOcc pass)
- = FieldOcc {
- type LFieldOcc pass = Located (FieldOcc pass)
- mkFieldOcc :: Located RdrName -> FieldOcc GhcPs
- data AmbiguousFieldOcc pass
- = Unambiguous (XUnambiguous pass) (Located RdrName)
- | Ambiguous (XAmbiguous pass) (Located RdrName)
- | XAmbiguousFieldOcc (XXAmbiguousFieldOcc pass)
- mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc GhcPs
- rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc (GhcPass p) -> RdrName
- selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id
- unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc
- ambiguousFieldOcc :: FieldOcc GhcTc -> AmbiguousFieldOcc GhcTc
- mkAnonWildCardTy :: HsType GhcPs
- pprAnonWildCard :: SDoc
- mkHsImplicitBndrs :: thing -> HsImplicitBndrs GhcPs thing
- mkHsWildCardBndrs :: thing -> HsWildCardBndrs GhcPs thing
- hsImplicitBody :: HsImplicitBndrs (GhcPass p) thing -> thing
- mkEmptyImplicitBndrs :: thing -> HsImplicitBndrs GhcRn thing
- mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs GhcRn thing
- mkHsQTvs :: [LHsTyVarBndr GhcPs] -> LHsQTyVars GhcPs
- hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr pass]
- emptyLHsQTvs :: LHsQTyVars GhcRn
- isEmptyLHsQTvs :: LHsQTyVars GhcRn -> Bool
- isHsKindedTyVar :: HsTyVarBndr pass -> Bool
- hsTvbAllKinded :: LHsQTyVars pass -> Bool
- isLHsForAllTy :: LHsType p -> Bool
- hsScopedTvs :: LHsSigType GhcRn -> [Name]
- hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name]
- dropWildCards :: LHsSigWcType pass -> LHsSigType pass
- hsTyVarName :: HsTyVarBndr (GhcPass p) -> IdP (GhcPass p)
- hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name]
- hsLTyVarLocNames :: LHsQTyVars (GhcPass p) -> [Located (IdP (GhcPass p))]
- hsLTyVarName :: LHsTyVarBndr (GhcPass p) -> IdP (GhcPass p)
- hsLTyVarNames :: [LHsTyVarBndr (GhcPass p)] -> [IdP (GhcPass p)]
- hsLTyVarLocName :: LHsTyVarBndr (GhcPass p) -> Located (IdP (GhcPass p))
- hsExplicitLTyVarNames :: LHsQTyVars (GhcPass p) -> [IdP (GhcPass p)]
- splitLHsInstDeclTy :: LHsSigType GhcRn -> ([Name], LHsContext GhcRn, LHsType GhcRn)
- getLHsInstDeclHead :: LHsSigType (GhcPass p) -> LHsType (GhcPass p)
- getLHsInstDeclClass_maybe :: LHsSigType (GhcPass p) -> Maybe (Located (IdP (GhcPass p)))
- splitLHsPatSynTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, [LHsTyVarBndr pass], LHsContext pass, LHsType pass)
- splitLHsForAllTyInvis :: LHsType pass -> ([LHsTyVarBndr pass], LHsType pass)
- splitLHsQualTy :: LHsType pass -> (LHsContext pass, LHsType pass)
- splitLHsSigmaTyInvis :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, LHsType pass)
- splitHsFunType :: LHsType GhcRn -> ([LHsType GhcRn], LHsType GhcRn)
- hsTyGetAppHead_maybe :: LHsType (GhcPass p) -> Maybe (Located (IdP (GhcPass p)))
- mkHsOpTy :: LHsType (GhcPass p) -> Located (IdP (GhcPass p)) -> LHsType (GhcPass p) -> HsType (GhcPass p)
- mkHsAppTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
- mkHsAppTys :: LHsType (GhcPass p) -> [LHsType (GhcPass p)] -> LHsType (GhcPass p)
- mkHsAppKindTy :: XAppKindTy (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
- ignoreParens :: LHsType pass -> LHsType pass
- hsSigType :: LHsSigType (GhcPass p) -> LHsType (GhcPass p)
- hsSigWcType :: LHsSigWcType pass -> LHsType pass
- hsLTyVarBndrToType :: LHsTyVarBndr (GhcPass p) -> LHsType (GhcPass p)
- hsLTyVarBndrsToTypes :: LHsQTyVars (GhcPass p) -> [LHsType (GhcPass p)]
- hsTyKindSig :: LHsType pass -> Maybe (LHsKind pass)
- hsConDetailsArgs :: HsConDetails (LHsType a) (Located [LConDeclField a]) -> [LHsType a]
- pprHsType :: OutputableBndrId p => HsType (GhcPass p) -> SDoc
- pprHsForAll :: OutputableBndrId p => ForallVisFlag -> [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc
- pprHsForAllExtra :: OutputableBndrId p => Maybe SrcSpan -> ForallVisFlag -> [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc
- pprHsExplicitForAll :: OutputableBndrId p => ForallVisFlag -> Maybe [LHsTyVarBndr (GhcPass p)] -> SDoc
- pprLHsContext :: OutputableBndrId p => LHsContext (GhcPass p) -> SDoc
- hsTypeNeedsParens :: PprPrec -> HsType pass -> Bool
- parenthesizeHsType :: PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p)
- parenthesizeHsContext :: PprPrec -> LHsContext (GhcPass p) -> LHsContext (GhcPass p)
Documentation
Haskell Type
Constructors
Instances
Data (LHsTypeArg GhcTc) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsTypeArg GhcTc -> c (LHsTypeArg GhcTc) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsTypeArg GhcTc) toConstr :: LHsTypeArg GhcTc -> Constr dataTypeOf :: LHsTypeArg GhcTc -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsTypeArg GhcTc)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsTypeArg GhcTc)) gmapT :: (forall b. Data b => b -> b) -> LHsTypeArg GhcTc -> LHsTypeArg GhcTc gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcTc -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcTc -> r gmapQ :: (forall d. Data d => d -> u) -> LHsTypeArg GhcTc -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsTypeArg GhcTc -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcTc -> m (LHsTypeArg GhcTc) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcTc -> m (LHsTypeArg GhcTc) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcTc -> m (LHsTypeArg GhcTc) | |
Data (LHsTypeArg GhcRn) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsTypeArg GhcRn -> c (LHsTypeArg GhcRn) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsTypeArg GhcRn) toConstr :: LHsTypeArg GhcRn -> Constr dataTypeOf :: LHsTypeArg GhcRn -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsTypeArg GhcRn)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsTypeArg GhcRn)) gmapT :: (forall b. Data b => b -> b) -> LHsTypeArg GhcRn -> LHsTypeArg GhcRn gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcRn -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcRn -> r gmapQ :: (forall d. Data d => d -> u) -> LHsTypeArg GhcRn -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsTypeArg GhcRn -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcRn -> m (LHsTypeArg GhcRn) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcRn -> m (LHsTypeArg GhcRn) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcRn -> m (LHsTypeArg GhcRn) | |
Data (LHsTypeArg GhcPs) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsTypeArg GhcPs -> c (LHsTypeArg GhcPs) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsTypeArg GhcPs) toConstr :: LHsTypeArg GhcPs -> Constr dataTypeOf :: LHsTypeArg GhcPs -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsTypeArg GhcPs)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsTypeArg GhcPs)) gmapT :: (forall b. Data b => b -> b) -> LHsTypeArg GhcPs -> LHsTypeArg GhcPs gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcPs -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcPs -> r gmapQ :: (forall d. Data d => d -> u) -> LHsTypeArg GhcPs -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsTypeArg GhcPs -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcPs -> m (LHsTypeArg GhcPs) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcPs -> m (LHsTypeArg GhcPs) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcPs -> m (LHsTypeArg GhcPs) | |
Data (HsType GhcTc) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType GhcTc -> c (HsType GhcTc) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsType GhcTc) toConstr :: HsType GhcTc -> Constr dataTypeOf :: HsType GhcTc -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsType GhcTc)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsType GhcTc)) gmapT :: (forall b. Data b => b -> b) -> HsType GhcTc -> HsType GhcTc gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcTc -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcTc -> r gmapQ :: (forall d. Data d => d -> u) -> HsType GhcTc -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType GhcTc -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType GhcTc -> m (HsType GhcTc) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcTc -> m (HsType GhcTc) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcTc -> m (HsType GhcTc) | |
Data (HsType GhcRn) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType GhcRn -> c (HsType GhcRn) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsType GhcRn) toConstr :: HsType GhcRn -> Constr dataTypeOf :: HsType GhcRn -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsType GhcRn)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsType GhcRn)) gmapT :: (forall b. Data b => b -> b) -> HsType GhcRn -> HsType GhcRn gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcRn -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcRn -> r gmapQ :: (forall d. Data d => d -> u) -> HsType GhcRn -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType GhcRn -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType GhcRn -> m (HsType GhcRn) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcRn -> m (HsType GhcRn) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcRn -> m (HsType GhcRn) | |
Data (HsType GhcPs) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType GhcPs -> c (HsType GhcPs) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsType GhcPs) toConstr :: HsType GhcPs -> Constr dataTypeOf :: HsType GhcPs -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsType GhcPs)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsType GhcPs)) gmapT :: (forall b. Data b => b -> b) -> HsType GhcPs -> HsType GhcPs gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcPs -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcPs -> r gmapQ :: (forall d. Data d => d -> u) -> HsType GhcPs -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType GhcPs -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType GhcPs -> m (HsType GhcPs) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcPs -> m (HsType GhcPs) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcPs -> m (HsType GhcPs) | |
OutputableBndrId p => Outputable (HsType (GhcPass p)) Source # | |
data NewHsTypeX Source #
Instances
Data NewHsTypeX Source # |
|
Defined in GHC.Hs.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NewHsTypeX -> c NewHsTypeX gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NewHsTypeX toConstr :: NewHsTypeX -> Constr dataTypeOf :: NewHsTypeX -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NewHsTypeX) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewHsTypeX) gmapT :: (forall b. Data b => b -> b) -> NewHsTypeX -> NewHsTypeX gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NewHsTypeX -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NewHsTypeX -> r gmapQ :: (forall d. Data d => d -> u) -> NewHsTypeX -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> NewHsTypeX -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> NewHsTypeX -> m NewHsTypeX gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NewHsTypeX -> m NewHsTypeX gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NewHsTypeX -> m NewHsTypeX | |
Outputable NewHsTypeX Source # | |
Defined in GHC.Hs.Types |
Arguments
= Located (HsType pass) | May have |
Located Haskell Type
data HsTyVarBndr pass Source #
Haskell Type Variable Binder
Constructors
UserTyVar (XUserTyVar pass) (Located (IdP pass)) | |
KindedTyVar (XKindedTyVar pass) (Located (IdP pass)) (LHsKind pass) | |
XTyVarBndr (XXTyVarBndr pass) |
Instances
Data (HsTyVarBndr GhcTc) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyVarBndr GhcTc -> c (HsTyVarBndr GhcTc) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyVarBndr GhcTc) toConstr :: HsTyVarBndr GhcTc -> Constr dataTypeOf :: HsTyVarBndr GhcTc -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsTyVarBndr GhcTc)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsTyVarBndr GhcTc)) gmapT :: (forall b. Data b => b -> b) -> HsTyVarBndr GhcTc -> HsTyVarBndr GhcTc gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcTc -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcTc -> r gmapQ :: (forall d. Data d => d -> u) -> HsTyVarBndr GhcTc -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyVarBndr GhcTc -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcTc -> m (HsTyVarBndr GhcTc) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcTc -> m (HsTyVarBndr GhcTc) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcTc -> m (HsTyVarBndr GhcTc) | |
Data (HsTyVarBndr GhcRn) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyVarBndr GhcRn -> c (HsTyVarBndr GhcRn) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyVarBndr GhcRn) toConstr :: HsTyVarBndr GhcRn -> Constr dataTypeOf :: HsTyVarBndr GhcRn -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsTyVarBndr GhcRn)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsTyVarBndr GhcRn)) gmapT :: (forall b. Data b => b -> b) -> HsTyVarBndr GhcRn -> HsTyVarBndr GhcRn gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcRn -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcRn -> r gmapQ :: (forall d. Data d => d -> u) -> HsTyVarBndr GhcRn -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyVarBndr GhcRn -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcRn -> m (HsTyVarBndr GhcRn) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcRn -> m (HsTyVarBndr GhcRn) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcRn -> m (HsTyVarBndr GhcRn) | |
Data (HsTyVarBndr GhcPs) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyVarBndr GhcPs -> c (HsTyVarBndr GhcPs) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyVarBndr GhcPs) toConstr :: HsTyVarBndr GhcPs -> Constr dataTypeOf :: HsTyVarBndr GhcPs -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsTyVarBndr GhcPs)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsTyVarBndr GhcPs)) gmapT :: (forall b. Data b => b -> b) -> HsTyVarBndr GhcPs -> HsTyVarBndr GhcPs gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcPs -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcPs -> r gmapQ :: (forall d. Data d => d -> u) -> HsTyVarBndr GhcPs -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyVarBndr GhcPs -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcPs -> m (HsTyVarBndr GhcPs) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcPs -> m (HsTyVarBndr GhcPs) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcPs -> m (HsTyVarBndr GhcPs) | |
OutputableBndrId p => Outputable (HsTyVarBndr (GhcPass p)) Source # | |
Defined in GHC.Hs.Types | |
NamedThing (HsTyVarBndr GhcRn) Source # | |
Defined in GHC.Hs.Types Methods getOccName :: HsTyVarBndr GhcRn -> OccName Source # |
type LHsTyVarBndr pass = Located (HsTyVarBndr pass) Source #
Located Haskell Type Variable Binder
data ForallVisFlag Source #
Is a forall
invisible (e.g., forall a b. {...}
, with a dot) or visible
(e.g., forall a b -> {...}
, with an arrow)?
Constructors
ForallVis | A visible |
ForallInvis | An invisible |
Instances
Eq ForallVisFlag Source # | |
Defined in Var Methods (==) :: ForallVisFlag -> ForallVisFlag -> Bool # (/=) :: ForallVisFlag -> ForallVisFlag -> Bool # | |
Data ForallVisFlag Source # | |
Defined in Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForallVisFlag -> c ForallVisFlag gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForallVisFlag toConstr :: ForallVisFlag -> Constr dataTypeOf :: ForallVisFlag -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ForallVisFlag) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForallVisFlag) gmapT :: (forall b. Data b => b -> b) -> ForallVisFlag -> ForallVisFlag gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForallVisFlag -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForallVisFlag -> r gmapQ :: (forall d. Data d => d -> u) -> ForallVisFlag -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> ForallVisFlag -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForallVisFlag -> m ForallVisFlag gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForallVisFlag -> m ForallVisFlag gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForallVisFlag -> m ForallVisFlag | |
Ord ForallVisFlag Source # | |
Defined in Var Methods compare :: ForallVisFlag -> ForallVisFlag -> Ordering # (<) :: ForallVisFlag -> ForallVisFlag -> Bool # (<=) :: ForallVisFlag -> ForallVisFlag -> Bool # (>) :: ForallVisFlag -> ForallVisFlag -> Bool # (>=) :: ForallVisFlag -> ForallVisFlag -> Bool # max :: ForallVisFlag -> ForallVisFlag -> ForallVisFlag # min :: ForallVisFlag -> ForallVisFlag -> ForallVisFlag # | |
Outputable ForallVisFlag Source # | |
data LHsQTyVars pass Source #
Located Haskell Quantified Type Variables
Constructors
HsQTvs | |
Fields
| |
XLHsQTyVars (XXLHsQTyVars pass) |
Instances
Data (LHsQTyVars GhcTc) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsQTyVars GhcTc -> c (LHsQTyVars GhcTc) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsQTyVars GhcTc) toConstr :: LHsQTyVars GhcTc -> Constr dataTypeOf :: LHsQTyVars GhcTc -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsQTyVars GhcTc)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsQTyVars GhcTc)) gmapT :: (forall b. Data b => b -> b) -> LHsQTyVars GhcTc -> LHsQTyVars GhcTc gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcTc -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcTc -> r gmapQ :: (forall d. Data d => d -> u) -> LHsQTyVars GhcTc -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsQTyVars GhcTc -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcTc -> m (LHsQTyVars GhcTc) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcTc -> m (LHsQTyVars GhcTc) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcTc -> m (LHsQTyVars GhcTc) | |
Data (LHsQTyVars GhcRn) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsQTyVars GhcRn -> c (LHsQTyVars GhcRn) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsQTyVars GhcRn) toConstr :: LHsQTyVars GhcRn -> Constr dataTypeOf :: LHsQTyVars GhcRn -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsQTyVars GhcRn)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsQTyVars GhcRn)) gmapT :: (forall b. Data b => b -> b) -> LHsQTyVars GhcRn -> LHsQTyVars GhcRn gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcRn -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcRn -> r gmapQ :: (forall d. Data d => d -> u) -> LHsQTyVars GhcRn -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsQTyVars GhcRn -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcRn -> m (LHsQTyVars GhcRn) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcRn -> m (LHsQTyVars GhcRn) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcRn -> m (LHsQTyVars GhcRn) | |
Data (LHsQTyVars GhcPs) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsQTyVars GhcPs -> c (LHsQTyVars GhcPs) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsQTyVars GhcPs) toConstr :: LHsQTyVars GhcPs -> Constr dataTypeOf :: LHsQTyVars GhcPs -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsQTyVars GhcPs)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsQTyVars GhcPs)) gmapT :: (forall b. Data b => b -> b) -> LHsQTyVars GhcPs -> LHsQTyVars GhcPs gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcPs -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcPs -> r gmapQ :: (forall d. Data d => d -> u) -> LHsQTyVars GhcPs -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsQTyVars GhcPs -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcPs -> m (LHsQTyVars GhcPs) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcPs -> m (LHsQTyVars GhcPs) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcPs -> m (LHsQTyVars GhcPs) | |
OutputableBndrId p => Outputable (LHsQTyVars (GhcPass p)) Source # | |
Defined in GHC.Hs.Types |
data HsImplicitBndrs pass thing Source #
Haskell Implicit Binders
Constructors
HsIB | |
XHsImplicitBndrs (XXHsImplicitBndrs pass thing) |
Instances
Data thing => Data (HsImplicitBndrs GhcTc thing) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImplicitBndrs GhcTc thing -> c (HsImplicitBndrs GhcTc thing) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsImplicitBndrs GhcTc thing) toConstr :: HsImplicitBndrs GhcTc thing -> Constr dataTypeOf :: HsImplicitBndrs GhcTc thing -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsImplicitBndrs GhcTc thing)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsImplicitBndrs GhcTc thing)) gmapT :: (forall b. Data b => b -> b) -> HsImplicitBndrs GhcTc thing -> HsImplicitBndrs GhcTc thing gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcTc thing -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcTc thing -> r gmapQ :: (forall d. Data d => d -> u) -> HsImplicitBndrs GhcTc thing -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImplicitBndrs GhcTc thing -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcTc thing -> m (HsImplicitBndrs GhcTc thing) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcTc thing -> m (HsImplicitBndrs GhcTc thing) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcTc thing -> m (HsImplicitBndrs GhcTc thing) | |
Data thing => Data (HsImplicitBndrs GhcRn thing) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImplicitBndrs GhcRn thing -> c (HsImplicitBndrs GhcRn thing) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsImplicitBndrs GhcRn thing) toConstr :: HsImplicitBndrs GhcRn thing -> Constr dataTypeOf :: HsImplicitBndrs GhcRn thing -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsImplicitBndrs GhcRn thing)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsImplicitBndrs GhcRn thing)) gmapT :: (forall b. Data b => b -> b) -> HsImplicitBndrs GhcRn thing -> HsImplicitBndrs GhcRn thing gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcRn thing -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcRn thing -> r gmapQ :: (forall d. Data d => d -> u) -> HsImplicitBndrs GhcRn thing -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImplicitBndrs GhcRn thing -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcRn thing -> m (HsImplicitBndrs GhcRn thing) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcRn thing -> m (HsImplicitBndrs GhcRn thing) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcRn thing -> m (HsImplicitBndrs GhcRn thing) | |
Data thing => Data (HsImplicitBndrs GhcPs thing) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImplicitBndrs GhcPs thing -> c (HsImplicitBndrs GhcPs thing) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsImplicitBndrs GhcPs thing) toConstr :: HsImplicitBndrs GhcPs thing -> Constr dataTypeOf :: HsImplicitBndrs GhcPs thing -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsImplicitBndrs GhcPs thing)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsImplicitBndrs GhcPs thing)) gmapT :: (forall b. Data b => b -> b) -> HsImplicitBndrs GhcPs thing -> HsImplicitBndrs GhcPs thing gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcPs thing -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcPs thing -> r gmapQ :: (forall d. Data d => d -> u) -> HsImplicitBndrs GhcPs thing -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImplicitBndrs GhcPs thing -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcPs thing -> m (HsImplicitBndrs GhcPs thing) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcPs thing -> m (HsImplicitBndrs GhcPs thing) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcPs thing -> m (HsImplicitBndrs GhcPs thing) | |
Outputable thing => Outputable (HsImplicitBndrs (GhcPass p) thing) Source # | |
Defined in GHC.Hs.Types |
data HsWildCardBndrs pass thing Source #
Haskell Wildcard Binders
Constructors
HsWC | |
XHsWildCardBndrs (XXHsWildCardBndrs pass thing) |
Instances
Data thing => Data (HsWildCardBndrs GhcTc thing) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsWildCardBndrs GhcTc thing -> c (HsWildCardBndrs GhcTc thing) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsWildCardBndrs GhcTc thing) toConstr :: HsWildCardBndrs GhcTc thing -> Constr dataTypeOf :: HsWildCardBndrs GhcTc thing -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsWildCardBndrs GhcTc thing)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsWildCardBndrs GhcTc thing)) gmapT :: (forall b. Data b => b -> b) -> HsWildCardBndrs GhcTc thing -> HsWildCardBndrs GhcTc thing gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcTc thing -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcTc thing -> r gmapQ :: (forall d. Data d => d -> u) -> HsWildCardBndrs GhcTc thing -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsWildCardBndrs GhcTc thing -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcTc thing -> m (HsWildCardBndrs GhcTc thing) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcTc thing -> m (HsWildCardBndrs GhcTc thing) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcTc thing -> m (HsWildCardBndrs GhcTc thing) | |
Data thing => Data (HsWildCardBndrs GhcRn thing) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsWildCardBndrs GhcRn thing -> c (HsWildCardBndrs GhcRn thing) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsWildCardBndrs GhcRn thing) toConstr :: HsWildCardBndrs GhcRn thing -> Constr dataTypeOf :: HsWildCardBndrs GhcRn thing -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsWildCardBndrs GhcRn thing)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsWildCardBndrs GhcRn thing)) gmapT :: (forall b. Data b => b -> b) -> HsWildCardBndrs GhcRn thing -> HsWildCardBndrs GhcRn thing gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcRn thing -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcRn thing -> r gmapQ :: (forall d. Data d => d -> u) -> HsWildCardBndrs GhcRn thing -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsWildCardBndrs GhcRn thing -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcRn thing -> m (HsWildCardBndrs GhcRn thing) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcRn thing -> m (HsWildCardBndrs GhcRn thing) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcRn thing -> m (HsWildCardBndrs GhcRn thing) | |
Data thing => Data (HsWildCardBndrs GhcPs thing) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsWildCardBndrs GhcPs thing -> c (HsWildCardBndrs GhcPs thing) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsWildCardBndrs GhcPs thing) toConstr :: HsWildCardBndrs GhcPs thing -> Constr dataTypeOf :: HsWildCardBndrs GhcPs thing -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsWildCardBndrs GhcPs thing)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsWildCardBndrs GhcPs thing)) gmapT :: (forall b. Data b => b -> b) -> HsWildCardBndrs GhcPs thing -> HsWildCardBndrs GhcPs thing gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcPs thing -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcPs thing -> r gmapQ :: (forall d. Data d => d -> u) -> HsWildCardBndrs GhcPs thing -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsWildCardBndrs GhcPs thing -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcPs thing -> m (HsWildCardBndrs GhcPs thing) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcPs thing -> m (HsWildCardBndrs GhcPs thing) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcPs thing -> m (HsWildCardBndrs GhcPs thing) | |
Outputable thing => Outputable (HsWildCardBndrs (GhcPass p) thing) Source # | |
Defined in GHC.Hs.Types |
type LHsSigType pass = HsImplicitBndrs pass (LHsType pass) Source #
Located Haskell Signature Type
type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass) Source #
Located Haskell Signature Wildcard Type
type LHsWcType pass = HsWildCardBndrs pass (LHsType pass) Source #
Located Haskell Wildcard Type
data HsTupleSort Source #
Haskell Tuple Sort
Instances
Data HsTupleSort Source # | |
Defined in GHC.Hs.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTupleSort -> c HsTupleSort gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsTupleSort toConstr :: HsTupleSort -> Constr dataTypeOf :: HsTupleSort -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsTupleSort) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsTupleSort) gmapT :: (forall b. Data b => b -> b) -> HsTupleSort -> HsTupleSort gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTupleSort -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTupleSort -> r gmapQ :: (forall d. Data d => d -> u) -> HsTupleSort -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTupleSort -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort |
type LHsContext pass Source #
Arguments
= Located (HsContext pass) |
|
Located Haskell Context
noLHsContext :: LHsContext pass Source #
Haskell Type Literal
Constructors
HsNumTy SourceText Integer | |
HsStrTy SourceText FastString |
Instances
Data HsTyLit Source # | |
Defined in GHC.Hs.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyLit -> c HsTyLit gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsTyLit dataTypeOf :: HsTyLit -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsTyLit) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsTyLit) gmapT :: (forall b. Data b => b -> b) -> HsTyLit -> HsTyLit gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit -> r gmapQ :: (forall d. Data d => d -> u) -> HsTyLit -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyLit -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyLit -> m HsTyLit gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit -> m HsTyLit gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit -> m HsTyLit | |
Outputable HsTyLit Source # | |
These names are used early on to store the names of implicit parameters. They completely disappear after type-checking.
Constructors
HsIPName FastString |
Instances
Eq HsIPName Source # | |
Data HsIPName Source # | |
Defined in GHC.Hs.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsIPName -> c HsIPName gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsIPName toConstr :: HsIPName -> Constr dataTypeOf :: HsIPName -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsIPName) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsIPName) gmapT :: (forall b. Data b => b -> b) -> HsIPName -> HsIPName gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsIPName -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsIPName -> r gmapQ :: (forall d. Data d => d -> u) -> HsIPName -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsIPName -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName | |
OutputableBndr HsIPName Source # | |
Defined in GHC.Hs.Types | |
Outputable HsIPName Source # | |
hsIPNameFS :: HsIPName -> FastString Source #
Instances
Data (LHsTypeArg GhcTc) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsTypeArg GhcTc -> c (LHsTypeArg GhcTc) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsTypeArg GhcTc) toConstr :: LHsTypeArg GhcTc -> Constr dataTypeOf :: LHsTypeArg GhcTc -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsTypeArg GhcTc)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsTypeArg GhcTc)) gmapT :: (forall b. Data b => b -> b) -> LHsTypeArg GhcTc -> LHsTypeArg GhcTc gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcTc -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcTc -> r gmapQ :: (forall d. Data d => d -> u) -> LHsTypeArg GhcTc -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsTypeArg GhcTc -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcTc -> m (LHsTypeArg GhcTc) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcTc -> m (LHsTypeArg GhcTc) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcTc -> m (LHsTypeArg GhcTc) | |
Data (LHsTypeArg GhcRn) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsTypeArg GhcRn -> c (LHsTypeArg GhcRn) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsTypeArg GhcRn) toConstr :: LHsTypeArg GhcRn -> Constr dataTypeOf :: LHsTypeArg GhcRn -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsTypeArg GhcRn)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsTypeArg GhcRn)) gmapT :: (forall b. Data b => b -> b) -> LHsTypeArg GhcRn -> LHsTypeArg GhcRn gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcRn -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcRn -> r gmapQ :: (forall d. Data d => d -> u) -> LHsTypeArg GhcRn -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsTypeArg GhcRn -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcRn -> m (LHsTypeArg GhcRn) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcRn -> m (LHsTypeArg GhcRn) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcRn -> m (LHsTypeArg GhcRn) | |
Data (LHsTypeArg GhcPs) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsTypeArg GhcPs -> c (LHsTypeArg GhcPs) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsTypeArg GhcPs) toConstr :: LHsTypeArg GhcPs -> Constr dataTypeOf :: LHsTypeArg GhcPs -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsTypeArg GhcPs)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsTypeArg GhcPs)) gmapT :: (forall b. Data b => b -> b) -> LHsTypeArg GhcPs -> LHsTypeArg GhcPs gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcPs -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsTypeArg GhcPs -> r gmapQ :: (forall d. Data d => d -> u) -> LHsTypeArg GhcPs -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsTypeArg GhcPs -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcPs -> m (LHsTypeArg GhcPs) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcPs -> m (LHsTypeArg GhcPs) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsTypeArg GhcPs -> m (LHsTypeArg GhcPs) | |
(Outputable tm, Outputable ty) => Outputable (HsArg tm ty) Source # | |
numVisibleArgs :: [HsArg tm ty] -> Arity Source #
type BangType pass = HsType pass Source #
Bang Type
In the parser, strictness and packedness annotations bind more tightly
than docstrings. This means that when consuming a BangType
(and looking
for HsBangTy
) we must be ready to peer behind a potential layer of
HsDocTy
. See #15206 for motivation and getBangType
for an example.
Haskell Source Bang
Bangs on data constructor arguments as the user wrote them in the source code.
(HsSrcBang _ SrcUnpack SrcLazy)
and
(HsSrcBang _ SrcUnpack NoSrcStrict)
(without StrictData) makes no sense, we
emit a warning (in checkValidDataCon) and treat it like
(HsSrcBang _ NoSrcUnpack SrcLazy)
Constructors
HsSrcBang SourceText SrcUnpackedness SrcStrictness |
Instances
Data HsSrcBang Source # | |
Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSrcBang -> c HsSrcBang gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsSrcBang toConstr :: HsSrcBang -> Constr dataTypeOf :: HsSrcBang -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsSrcBang) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSrcBang) gmapT :: (forall b. Data b => b -> b) -> HsSrcBang -> HsSrcBang gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r gmapQ :: (forall d. Data d => d -> u) -> HsSrcBang -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSrcBang -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang | |
Outputable HsSrcBang Source # | |
data HsImplBang Source #
Haskell Implementation Bang
Bangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.
Constructors
HsLazy | Lazy field, or one with an unlifted type |
HsStrict | Strict but not unpacked field |
HsUnpack (Maybe Coercion) | Strict and unpacked field co :: arg-ty ~ product-ty HsBang |
Instances
Data HsImplBang Source # | |
Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImplBang -> c HsImplBang gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsImplBang toConstr :: HsImplBang -> Constr dataTypeOf :: HsImplBang -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsImplBang) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsImplBang) gmapT :: (forall b. Data b => b -> b) -> HsImplBang -> HsImplBang gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImplBang -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImplBang -> r gmapQ :: (forall d. Data d => d -> u) -> HsImplBang -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImplBang -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang | |
Outputable HsImplBang Source # | |
data SrcStrictness Source #
Source Strictness
What strictness annotation the user wrote
Constructors
SrcLazy | Lazy, ie '~' |
SrcStrict | Strict, ie |
NoSrcStrict | no strictness annotation |
Instances
Eq SrcStrictness Source # | |
Defined in DataCon Methods (==) :: SrcStrictness -> SrcStrictness -> Bool # (/=) :: SrcStrictness -> SrcStrictness -> Bool # | |
Data SrcStrictness Source # | |
Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcStrictness -> c SrcStrictness gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcStrictness toConstr :: SrcStrictness -> Constr dataTypeOf :: SrcStrictness -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcStrictness) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcStrictness) gmapT :: (forall b. Data b => b -> b) -> SrcStrictness -> SrcStrictness gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r gmapQ :: (forall d. Data d => d -> u) -> SrcStrictness -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcStrictness -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness | |
Outputable SrcStrictness Source # | |
Binary SrcStrictness Source # | |
data SrcUnpackedness Source #
Source Unpackedness
What unpackedness the user requested
Constructors
SrcUnpack | {-# UNPACK #-} specified |
SrcNoUnpack | {-# NOUNPACK #-} specified |
NoSrcUnpack | no unpack pragma |
Instances
Eq SrcUnpackedness Source # | |
Defined in DataCon Methods (==) :: SrcUnpackedness -> SrcUnpackedness -> Bool # (/=) :: SrcUnpackedness -> SrcUnpackedness -> Bool # | |
Data SrcUnpackedness Source # | |
Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcUnpackedness -> c SrcUnpackedness gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcUnpackedness toConstr :: SrcUnpackedness -> Constr dataTypeOf :: SrcUnpackedness -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcUnpackedness) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcUnpackedness) gmapT :: (forall b. Data b => b -> b) -> SrcUnpackedness -> SrcUnpackedness gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r gmapQ :: (forall d. Data d => d -> u) -> SrcUnpackedness -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcUnpackedness -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness | |
Outputable SrcUnpackedness Source # | |
Binary SrcUnpackedness Source # | |
getBangType :: LHsType a -> LHsType a Source #
getBangStrictness :: LHsType a -> HsSrcBang Source #
data ConDeclField pass Source #
Constructor Declaration Field
Constructors
ConDeclField | |
Fields
| |
XConDeclField (XXConDeclField pass) |
Instances
Data (ConDeclField GhcTc) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDeclField GhcTc -> c (ConDeclField GhcTc) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDeclField GhcTc) toConstr :: ConDeclField GhcTc -> Constr dataTypeOf :: ConDeclField GhcTc -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDeclField GhcTc)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDeclField GhcTc)) gmapT :: (forall b. Data b => b -> b) -> ConDeclField GhcTc -> ConDeclField GhcTc gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcTc -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcTc -> r gmapQ :: (forall d. Data d => d -> u) -> ConDeclField GhcTc -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDeclField GhcTc -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDeclField GhcTc -> m (ConDeclField GhcTc) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcTc -> m (ConDeclField GhcTc) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcTc -> m (ConDeclField GhcTc) | |
Data (ConDeclField GhcRn) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDeclField GhcRn -> c (ConDeclField GhcRn) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDeclField GhcRn) toConstr :: ConDeclField GhcRn -> Constr dataTypeOf :: ConDeclField GhcRn -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDeclField GhcRn)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDeclField GhcRn)) gmapT :: (forall b. Data b => b -> b) -> ConDeclField GhcRn -> ConDeclField GhcRn gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcRn -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcRn -> r gmapQ :: (forall d. Data d => d -> u) -> ConDeclField GhcRn -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDeclField GhcRn -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDeclField GhcRn -> m (ConDeclField GhcRn) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcRn -> m (ConDeclField GhcRn) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcRn -> m (ConDeclField GhcRn) | |
Data (ConDeclField GhcPs) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDeclField GhcPs -> c (ConDeclField GhcPs) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDeclField GhcPs) toConstr :: ConDeclField GhcPs -> Constr dataTypeOf :: ConDeclField GhcPs -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDeclField GhcPs)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDeclField GhcPs)) gmapT :: (forall b. Data b => b -> b) -> ConDeclField GhcPs -> ConDeclField GhcPs gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcPs -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcPs -> r gmapQ :: (forall d. Data d => d -> u) -> ConDeclField GhcPs -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDeclField GhcPs -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDeclField GhcPs -> m (ConDeclField GhcPs) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcPs -> m (ConDeclField GhcPs) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcPs -> m (ConDeclField GhcPs) | |
OutputableBndrId p => Outputable (ConDeclField (GhcPass p)) Source # | |
Defined in GHC.Hs.Types |
type LConDeclField pass Source #
Arguments
= Located (ConDeclField pass) | May have |
Located Constructor Declaration Field
pprConDeclFields :: OutputableBndrId p => [LConDeclField (GhcPass p)] -> SDoc Source #
data HsConDetails arg rec Source #
Haskell Constructor Details
Instances
(Data arg, Data rec) => Data (HsConDetails arg rec) Source # | |
Defined in GHC.Hs.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDetails arg rec -> c (HsConDetails arg rec) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDetails arg rec) toConstr :: HsConDetails arg rec -> Constr dataTypeOf :: HsConDetails arg rec -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDetails arg rec)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDetails arg rec)) gmapT :: (forall b. Data b => b -> b) -> HsConDetails arg rec -> HsConDetails arg rec gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r gmapQ :: (forall d. Data d => d -> u) -> HsConDetails arg rec -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDetails arg rec -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) | |
(Outputable arg, Outputable rec) => Outputable (HsConDetails arg rec) Source # | |
Defined in GHC.Hs.Types |
Field Occurrence
Represents an *occurrence* of an unambiguous field. We store
both the RdrName
the user originally wrote, and after the
renamer, the selector function.
Constructors
FieldOcc | |
Fields
| |
XFieldOcc (XXFieldOcc pass) |
Instances
Eq (XCFieldOcc (GhcPass p)) => Eq (FieldOcc (GhcPass p)) Source # | |
Data (FieldOcc GhcTc) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldOcc GhcTc -> c (FieldOcc GhcTc) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldOcc GhcTc) toConstr :: FieldOcc GhcTc -> Constr dataTypeOf :: FieldOcc GhcTc -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldOcc GhcTc)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldOcc GhcTc)) gmapT :: (forall b. Data b => b -> b) -> FieldOcc GhcTc -> FieldOcc GhcTc gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcTc -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcTc -> r gmapQ :: (forall d. Data d => d -> u) -> FieldOcc GhcTc -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldOcc GhcTc -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldOcc GhcTc -> m (FieldOcc GhcTc) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcTc -> m (FieldOcc GhcTc) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcTc -> m (FieldOcc GhcTc) | |
Data (FieldOcc GhcRn) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldOcc GhcRn -> c (FieldOcc GhcRn) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldOcc GhcRn) toConstr :: FieldOcc GhcRn -> Constr dataTypeOf :: FieldOcc GhcRn -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldOcc GhcRn)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldOcc GhcRn)) gmapT :: (forall b. Data b => b -> b) -> FieldOcc GhcRn -> FieldOcc GhcRn gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcRn -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcRn -> r gmapQ :: (forall d. Data d => d -> u) -> FieldOcc GhcRn -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldOcc GhcRn -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldOcc GhcRn -> m (FieldOcc GhcRn) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcRn -> m (FieldOcc GhcRn) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcRn -> m (FieldOcc GhcRn) | |
Data (FieldOcc GhcPs) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldOcc GhcPs -> c (FieldOcc GhcPs) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldOcc GhcPs) toConstr :: FieldOcc GhcPs -> Constr dataTypeOf :: FieldOcc GhcPs -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldOcc GhcPs)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldOcc GhcPs)) gmapT :: (forall b. Data b => b -> b) -> FieldOcc GhcPs -> FieldOcc GhcPs gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcPs -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcPs -> r gmapQ :: (forall d. Data d => d -> u) -> FieldOcc GhcPs -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldOcc GhcPs -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldOcc GhcPs -> m (FieldOcc GhcPs) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcPs -> m (FieldOcc GhcPs) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcPs -> m (FieldOcc GhcPs) | |
Ord (XCFieldOcc (GhcPass p)) => Ord (FieldOcc (GhcPass p)) Source # | |
Defined in GHC.Hs.Types Methods compare :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Ordering # (<) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # (<=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # (>) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # (>=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # max :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) # min :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) # | |
Outputable (FieldOcc pass) Source # | |
data AmbiguousFieldOcc pass Source #
Ambiguous Field Occurrence
Represents an *occurrence* of a field that is potentially
ambiguous after the renamer, with the ambiguity resolved by the
typechecker. We always store the RdrName
that the user
originally wrote, and store the selector function after the renamer
(for unambiguous occurrences) or the typechecker (for ambiguous
occurrences).
See Note [HsRecField and HsRecUpdField] in GHC.Hs.Pat and Note [Disambiguating record fields] in TcExpr. See Note [Located RdrNames] in GHC.Hs.Expr
Constructors
Unambiguous (XUnambiguous pass) (Located RdrName) | |
Ambiguous (XAmbiguous pass) (Located RdrName) | |
XAmbiguousFieldOcc (XXAmbiguousFieldOcc pass) |
Instances
Data (AmbiguousFieldOcc GhcTc) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AmbiguousFieldOcc GhcTc -> c (AmbiguousFieldOcc GhcTc) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AmbiguousFieldOcc GhcTc) toConstr :: AmbiguousFieldOcc GhcTc -> Constr dataTypeOf :: AmbiguousFieldOcc GhcTc -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AmbiguousFieldOcc GhcTc)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AmbiguousFieldOcc GhcTc)) gmapT :: (forall b. Data b => b -> b) -> AmbiguousFieldOcc GhcTc -> AmbiguousFieldOcc GhcTc gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcTc -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcTc -> r gmapQ :: (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcTc -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcTc -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcTc -> m (AmbiguousFieldOcc GhcTc) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcTc -> m (AmbiguousFieldOcc GhcTc) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcTc -> m (AmbiguousFieldOcc GhcTc) | |
Data (AmbiguousFieldOcc GhcRn) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AmbiguousFieldOcc GhcRn -> c (AmbiguousFieldOcc GhcRn) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AmbiguousFieldOcc GhcRn) toConstr :: AmbiguousFieldOcc GhcRn -> Constr dataTypeOf :: AmbiguousFieldOcc GhcRn -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AmbiguousFieldOcc GhcRn)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AmbiguousFieldOcc GhcRn)) gmapT :: (forall b. Data b => b -> b) -> AmbiguousFieldOcc GhcRn -> AmbiguousFieldOcc GhcRn gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcRn -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcRn -> r gmapQ :: (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcRn -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcRn -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcRn -> m (AmbiguousFieldOcc GhcRn) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcRn -> m (AmbiguousFieldOcc GhcRn) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcRn -> m (AmbiguousFieldOcc GhcRn) | |
Data (AmbiguousFieldOcc GhcPs) | |
Defined in GHC.Hs.Instances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AmbiguousFieldOcc GhcPs -> c (AmbiguousFieldOcc GhcPs) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AmbiguousFieldOcc GhcPs) toConstr :: AmbiguousFieldOcc GhcPs -> Constr dataTypeOf :: AmbiguousFieldOcc GhcPs -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AmbiguousFieldOcc GhcPs)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AmbiguousFieldOcc GhcPs)) gmapT :: (forall b. Data b => b -> b) -> AmbiguousFieldOcc GhcPs -> AmbiguousFieldOcc GhcPs gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcPs -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcPs -> r gmapQ :: (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcPs -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcPs -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcPs -> m (AmbiguousFieldOcc GhcPs) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcPs -> m (AmbiguousFieldOcc GhcPs) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcPs -> m (AmbiguousFieldOcc GhcPs) | |
OutputableBndr (AmbiguousFieldOcc (GhcPass p)) Source # | |
Defined in GHC.Hs.Types Methods pprBndr :: BindingSite -> AmbiguousFieldOcc (GhcPass p) -> SDoc Source # pprPrefixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc Source # pprInfixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc Source # bndrIsJoin_maybe :: AmbiguousFieldOcc (GhcPass p) -> Maybe Int Source # | |
Outputable (AmbiguousFieldOcc (GhcPass p)) Source # | |
Defined in GHC.Hs.Types |
mkHsImplicitBndrs :: thing -> HsImplicitBndrs GhcPs thing Source #
mkHsWildCardBndrs :: thing -> HsWildCardBndrs GhcPs thing Source #
hsImplicitBody :: HsImplicitBndrs (GhcPass p) thing -> thing Source #
mkEmptyImplicitBndrs :: thing -> HsImplicitBndrs GhcRn thing Source #
mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs GhcRn thing Source #
mkHsQTvs :: [LHsTyVarBndr GhcPs] -> LHsQTyVars GhcPs Source #
hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr pass] Source #
isEmptyLHsQTvs :: LHsQTyVars GhcRn -> Bool Source #
isHsKindedTyVar :: HsTyVarBndr pass -> Bool Source #
Does this HsTyVarBndr
come with an explicit kind annotation?
hsTvbAllKinded :: LHsQTyVars pass -> Bool Source #
Do all type variables in this LHsQTyVars
come with kind annotations?
isLHsForAllTy :: LHsType p -> Bool Source #
hsScopedTvs :: LHsSigType GhcRn -> [Name] Source #
hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name] Source #
dropWildCards :: LHsSigWcType pass -> LHsSigType pass Source #
hsTyVarName :: HsTyVarBndr (GhcPass p) -> IdP (GhcPass p) Source #
hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name] Source #
hsLTyVarLocNames :: LHsQTyVars (GhcPass p) -> [Located (IdP (GhcPass p))] Source #
hsLTyVarName :: LHsTyVarBndr (GhcPass p) -> IdP (GhcPass p) Source #
hsLTyVarNames :: [LHsTyVarBndr (GhcPass p)] -> [IdP (GhcPass p)] Source #
hsLTyVarLocName :: LHsTyVarBndr (GhcPass p) -> Located (IdP (GhcPass p)) Source #
hsExplicitLTyVarNames :: LHsQTyVars (GhcPass p) -> [IdP (GhcPass p)] Source #
splitLHsInstDeclTy :: LHsSigType GhcRn -> ([Name], LHsContext GhcRn, LHsType GhcRn) Source #
Decompose a type class instance type (of the form
forall tvs. context => instance_head
) into its constituent parts.
Note that this function looks through parentheses, so it will work on types
such as (forall tvs. ...)
. The downside to this is that it is not
generally possible to take the returned types and reconstruct the original
type (parentheses and all) from them.
getLHsInstDeclHead :: LHsSigType (GhcPass p) -> LHsType (GhcPass p) Source #
getLHsInstDeclClass_maybe :: LHsSigType (GhcPass p) -> Maybe (Located (IdP (GhcPass p))) Source #
splitLHsPatSynTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, [LHsTyVarBndr pass], LHsContext pass, LHsType pass) Source #
Decompose a pattern synonym type signature into its constituent parts.
Note that this function looks through parentheses, so it will work on types
such as (forall a. ...)
. The downside to this is that it is not
generally possible to take the returned types and reconstruct the original
type (parentheses and all) from them.
splitLHsForAllTyInvis :: LHsType pass -> ([LHsTyVarBndr pass], LHsType pass) Source #
Decompose a type of the form forall tvs. body
into its constituent
parts. Note that only invisible forall
s
(i.e., forall a.
, with a dot) are split apart; visible forall
s
(i.e., forall a ->
, with an arrow) are left untouched.
This function is used to split apart certain types, such as instance
declaration types, which disallow visible forall
s. For instance, if GHC
split apart the forall
in instance forall a -> Show (Blah a)
, then that
declaration would mistakenly be accepted!
Note that this function looks through parentheses, so it will work on types
such as (forall a. ...)
. The downside to this is that it is not
generally possible to take the returned types and reconstruct the original
type (parentheses and all) from them.
splitLHsQualTy :: LHsType pass -> (LHsContext pass, LHsType pass) Source #
Decompose a type of the form context => body
into its constituent parts.
Note that this function looks through parentheses, so it will work on types
such as (context => ...)
. The downside to this is that it is not
generally possible to take the returned types and reconstruct the original
type (parentheses and all) from them.
splitLHsSigmaTyInvis :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, LHsType pass) Source #
Decompose a sigma type (of the form forall tvs. context => body
)
into its constituent parts. Note that only invisible forall
s
(i.e., forall a.
, with a dot) are split apart; visible forall
s
(i.e., forall a ->
, with an arrow) are left untouched.
This function is used to split apart certain types, such as instance
declaration types, which disallow visible forall
s. For instance, if GHC
split apart the forall
in instance forall a -> Show (Blah a)
, then that
declaration would mistakenly be accepted!
Note that this function looks through parentheses, so it will work on types
such as (forall a. ...)
. The downside to this is that it is not
generally possible to take the returned types and reconstruct the original
type (parentheses and all) from them.
mkHsOpTy :: LHsType (GhcPass p) -> Located (IdP (GhcPass p)) -> LHsType (GhcPass p) -> HsType (GhcPass p) Source #
mkHsAppKindTy :: XAppKindTy (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) Source #
ignoreParens :: LHsType pass -> LHsType pass Source #
hsSigWcType :: LHsSigWcType pass -> LHsType pass Source #
hsLTyVarBndrToType :: LHsTyVarBndr (GhcPass p) -> LHsType (GhcPass p) Source #
Convert a LHsTyVarBndr to an equivalent LHsType.
hsLTyVarBndrsToTypes :: LHsQTyVars (GhcPass p) -> [LHsType (GhcPass p)] Source #
Convert a LHsTyVarBndrs to a list of types. Works on *type* variable only, no kind vars.
hsTyKindSig :: LHsType pass -> Maybe (LHsKind pass) Source #
Get the kind signature of a type, ignoring parentheses:
hsTyKindSig `Maybe ` = Nothing hsTyKindSig `Maybe :: Type -> Type ` = Just `Type -> Type` hsTyKindSig `Maybe :: ((Type -> Type))` = Just `Type -> Type`
This is used to extract the result kind of type synonyms with a CUSK:
type S = (F :: res_kind) ^^^^^^^^
hsConDetailsArgs :: HsConDetails (LHsType a) (Located [LConDeclField a]) -> [LHsType a] Source #
pprHsForAll :: OutputableBndrId p => ForallVisFlag -> [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc Source #
Prints a forall; When passed an empty list, prints forall .
/forall ->
only when -dppr-debug
is enabled.
pprHsForAllExtra :: OutputableBndrId p => Maybe SrcSpan -> ForallVisFlag -> [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc Source #
Version of pprHsForAll
that can also print an extra-constraints
wildcard, e.g. _ => a -> Bool
or (Show a, _) => a -> String
. This
underscore will be printed when the 'Maybe SrcSpan' argument is a Just
containing the location of the extra-constraints wildcard. A special
function for this is needed, as the extra-constraints wildcard is removed
from the actual context and type, and stored in a separate field, thus just
printing the type will not print the extra-constraints wildcard.
pprHsExplicitForAll :: OutputableBndrId p => ForallVisFlag -> Maybe [LHsTyVarBndr (GhcPass p)] -> SDoc Source #
Version of pprHsForAll
or pprHsForAllExtra
that will always print
forall.
when passed Just []
. Prints nothing if passed Nothing
pprLHsContext :: OutputableBndrId p => LHsContext (GhcPass p) -> SDoc Source #
hsTypeNeedsParens :: PprPrec -> HsType pass -> Bool Source #
returns hsTypeNeedsParens
p tTrue
if the type t
needs parentheses
under precedence p
.
parenthesizeHsType :: PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p) Source #
checks if parenthesizeHsType
p ty
is
true, and if so, surrounds hsTypeNeedsParens
p tyty
with an HsParTy
. Otherwise, it simply
returns ty
.
parenthesizeHsContext :: PprPrec -> LHsContext (GhcPass p) -> LHsContext (GhcPass p) Source #
checks if parenthesizeHsContext
p ctxtctxt
is a single constraint
c
such that
is true, and if so, surrounds hsTypeNeedsParens
p cc
with an HsParTy
to form a parenthesized ctxt
. Otherwise, it simply
returns ctxt
unchanged.