Safe Haskell	None
Language	Haskell2010

HsTypes

Synopsis

data HsType pass
- = HsForAllTy {
  - hst_xforall :: XForAllTy pass
  - hst_bndrs :: [LHsTyVarBndr pass]
  - hst_body :: LHsType pass
  }
- | HsQualTy {
  - hst_xqual :: XQualTy pass
  - hst_ctxt :: LHsContext pass
  - hst_body :: LHsType pass
  }
- | HsTyVar (XTyVar pass) Promoted (Located (IdP pass))
- | HsAppTy (XAppTy pass) (LHsType pass) (LHsType 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) Promoted [LHsType pass]
- | HsExplicitTupleTy (XExplicitTupleTy pass) [LHsType pass]
- | HsTyLit (XTyLit pass) HsTyLit
- | HsWildCardTy (XWildCardTy pass)
- | XHsType (XXType pass)
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 LHsQTyVars pass
- = HsQTvs {
  - hsq_ext :: XHsQTvs pass
  - hsq_explicit :: [LHsTyVarBndr pass]
  }
- | XLHsQTyVars (XXLHsQTyVars pass)
data HsQTvsRn = HsQTvsRn {
- hsq_implicit :: [Name]
- hsq_dependent :: NameSet
}
data HsImplicitBndrs pass thing
- = HsIB {
  - hsib_ext :: XHsIB pass thing
  - hsib_body :: thing
  }
- | XHsImplicitBndrs (XXHsImplicitBndrs pass thing)
data HsIBRn = HsIBRn {
- hsib_vars :: [Name]
- hsib_closed :: Bool
}
data HsWildCardBndrs pass thing
- = HsWC {
  - hswc_ext :: XHsWC pass thing
  - hswc_body :: thing
  }
- | 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
- = HsUnboxedTuple
- | HsBoxedTuple
- | HsConstraintTuple
- | HsBoxedOrConstraintTuple
data Promoted
- = Promoted
- | NotPromoted
type HsContext pass = [LHsType pass]
type LHsContext pass = Located (HsContext pass)
data HsTyLit
- = HsNumTy SourceText Integer
- | HsStrTy SourceText FastString
newtype HsIPName = HsIPName FastString
hsIPNameFS :: HsIPName -> FastString
type LBangType pass = Located (BangType pass)
type BangType pass = HsType pass
data HsSrcBang = HsSrcBang SourceText SrcUnpackedness SrcStrictness
data HsImplBang
- = HsLazy
- | HsStrict
- | HsUnpack (Maybe Coercion)
data SrcStrictness
- = SrcLazy
- | SrcStrict
- | NoSrcStrict
data SrcUnpackedness
- = SrcUnpack
- | SrcNoUnpack
- | NoSrcUnpack
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)
type LConDeclField pass = Located (ConDeclField pass)
pprConDeclFields :: OutputableBndrId (GhcPass p) => [LConDeclField (GhcPass p)] -> SDoc
data HsConDetails arg rec
- = PrefixCon [arg]
- | RecCon rec
- | InfixCon arg arg
data FieldOcc pass
- = FieldOcc {
  - extFieldOcc :: XCFieldOcc pass
  - rdrNameFieldOcc :: Located RdrName
  }
- | XFieldOcc (XXFieldOcc pass)
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
newtype HsWildCardInfo = AnonWildCard (Located Name)
mkAnonWildCardTy :: HsType GhcPs
pprAnonWildCard :: SDoc
wildCardName :: HsWildCardInfo -> Name
sameWildCard :: Located HsWildCardInfo -> Located HsWildCardInfo -> Bool
mkHsImplicitBndrs :: thing -> HsImplicitBndrs GhcPs thing
mkHsWildCardBndrs :: thing -> HsWildCardBndrs GhcPs thing
hsImplicitBody :: HsImplicitBndrs pass 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 pass -> IdP pass
hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name]
hsLTyVarLocNames :: LHsQTyVars pass -> [Located (IdP pass)]
hsLTyVarName :: LHsTyVarBndr pass -> IdP pass
hsLTyVarLocName :: LHsTyVarBndr pass -> Located (IdP pass)
hsExplicitLTyVarNames :: LHsQTyVars pass -> [IdP pass]
splitLHsInstDeclTy :: LHsSigType GhcRn -> ([Name], LHsContext GhcRn, LHsType GhcRn)
getLHsInstDeclHead :: LHsSigType pass -> LHsType pass
getLHsInstDeclClass_maybe :: LHsSigType (GhcPass p) -> Maybe (Located (IdP (GhcPass p)))
splitLHsPatSynTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, [LHsTyVarBndr pass], LHsContext pass, LHsType pass)
splitLHsForAllTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsType pass)
splitLHsQualTy :: LHsType pass -> (LHsContext pass, LHsType pass)
splitLHsSigmaTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, LHsType pass)
splitHsFunType :: LHsType GhcRn -> ([LHsType GhcRn], LHsType GhcRn)
splitHsAppTys :: LHsType GhcRn -> [LHsType GhcRn] -> (LHsType GhcRn, [LHsType GhcRn])
hsTyGetAppHead_maybe :: LHsType (GhcPass p) -> Maybe (Located (IdP (GhcPass p)), [LHsType (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)
ignoreParens :: LHsType pass -> LHsType pass
hsSigType :: LHsSigType pass -> LHsType pass
hsSigWcType :: LHsSigWcType pass -> LHsType pass
hsLTyVarBndrToType :: LHsTyVarBndr (GhcPass p) -> LHsType (GhcPass p)
hsLTyVarBndrsToTypes :: LHsQTyVars (GhcPass p) -> [LHsType (GhcPass p)]
pprHsType :: OutputableBndrId (GhcPass p) => HsType (GhcPass p) -> SDoc
pprHsForAll :: OutputableBndrId (GhcPass p) => [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc
pprHsForAllTvs :: OutputableBndrId (GhcPass p) => [LHsTyVarBndr (GhcPass p)] -> SDoc
pprHsForAllExtra :: OutputableBndrId (GhcPass p) => Maybe SrcSpan -> [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc
pprHsContext :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> SDoc
pprHsContextNoArrow :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> SDoc
pprHsContextMaybe :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> Maybe SDoc
hsTypeNeedsParens :: PprPrec -> HsType pass -> Bool
parenthesizeHsType :: PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p)

Documentation

data HsType pass Source #

Haskell Type

Constructors

HsForAllTy	`AnnKeywordId` : `AnnForall`, `AnnDot`,`AnnDarrow` For details on above see note [Api annotations] in ApiAnnotation
Fields hst_xforall :: XForAllTy pass hst_bndrs :: [LHsTyVarBndr pass] hst_body :: LHsType pass
HsQualTy
Fields hst_xqual :: XQualTy pass hst_ctxt :: LHsContext pass hst_body :: LHsType pass
HsTyVar (XTyVar pass) Promoted (Located (IdP pass))	`AnnKeywordId` : None
HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)	`AnnKeywordId` : None
HsFunTy (XFunTy pass) (LHsType pass) (LHsType pass)	`AnnKeywordId` : `AnnRarrow`,
HsListTy (XListTy pass) (LHsType pass)	`AnnKeywordId` : `AnnOpen` `'['`, `AnnClose` `']'`
HsTupleTy (XTupleTy pass) HsTupleSort [LHsType pass]	`AnnKeywordId` : `AnnOpen` `'(' or '(#'`, `AnnClose` `')' or '#)'`
HsSumTy (XSumTy pass) [LHsType pass]	`AnnKeywordId` : `AnnOpen` `'(#'`, `AnnClose` '#)'@
HsOpTy (XOpTy pass) (LHsType pass) (Located (IdP pass)) (LHsType pass)	`AnnKeywordId` : None
HsParTy (XParTy pass) (LHsType pass)	`AnnKeywordId` : `AnnOpen` `'('`, `AnnClose` `')'`
HsIParamTy (XIParamTy pass) (Located HsIPName) (LHsType pass)	(?x :: ty) `AnnKeywordId` : `AnnDcolon`
HsStarTy (XStarTy pass) Bool	`AnnKeywordId` : None
HsKindSig (XKindSig pass) (LHsType pass) (LHsKind pass)	(ty :: kind) `AnnKeywordId` : `AnnOpen` `'('`, `AnnDcolon`,`AnnClose` `')'`
HsSpliceTy (XSpliceTy pass) (HsSplice pass)	`AnnKeywordId` : `AnnOpen` `'$('`, `AnnClose` `')'`
HsDocTy (XDocTy pass) (LHsType pass) LHsDocString	`AnnKeywordId` : None
HsBangTy (XBangTy pass) HsSrcBang (LHsType pass)	`AnnKeywordId` : `AnnOpen` `'{-# UNPACK' or '{-# NOUNPACK'`, `AnnClose` `'#-}'` `AnnBang` `'!'`
HsRecTy (XRecTy pass) [LConDeclField pass]	`AnnKeywordId` : `AnnOpen` `'{'`, `AnnClose` `'}'`
HsExplicitListTy (XExplicitListTy pass) Promoted [LHsType pass]	`AnnKeywordId` : `AnnOpen` `"'["`, `AnnClose` `']'`
HsExplicitTupleTy (XExplicitTupleTy pass) [LHsType pass]	`AnnKeywordId` : `AnnOpen` `"'("`, `AnnClose` `')'`
HsTyLit (XTyLit pass) HsTyLit	`AnnKeywordId` : None
HsWildCardTy (XWildCardTy pass)	`AnnKeywordId` : None
XHsType (XXType pass)

Instances

Data (HsType GhcTc) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType GhcTc -> c (HsType GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsType GhcTc) Source # toConstr :: HsType GhcTc -> Constr Source # dataTypeOf :: HsType GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsType GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsType GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> HsType GhcTc -> HsType GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcTc -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsType GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType GhcTc -> m (HsType GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcTc -> m (HsType GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcTc -> m (HsType GhcTc) Source #
Data (HsType GhcRn) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType GhcRn -> c (HsType GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsType GhcRn) Source # toConstr :: HsType GhcRn -> Constr Source # dataTypeOf :: HsType GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsType GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsType GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> HsType GhcRn -> HsType GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcRn -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsType GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType GhcRn -> m (HsType GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcRn -> m (HsType GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcRn -> m (HsType GhcRn) Source #
Data (HsType GhcPs) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType GhcPs -> c (HsType GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsType GhcPs) Source # toConstr :: HsType GhcPs -> Constr Source # dataTypeOf :: HsType GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsType GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsType GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> HsType GhcPs -> HsType GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcPs -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsType GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType GhcPs -> m (HsType GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcPs -> m (HsType GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcPs -> m (HsType GhcPs) Source #
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsType p) #
Instance details Defined in HsTypes Methods ppr :: HsType p -> SDoc Source # pprPrec :: Rational -> HsType p -> SDoc Source #

data NewHsTypeX Source #

Constructors

NHsCoreTy Type

Instances

Data NewHsTypeX #	`AnnKeywordId` : None
Instance details Defined in HsTypes Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NewHsTypeX -> c NewHsTypeX Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NewHsTypeX Source # toConstr :: NewHsTypeX -> Constr Source # dataTypeOf :: NewHsTypeX -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NewHsTypeX) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewHsTypeX) Source # gmapT :: (forall b. Data b => b -> b) -> NewHsTypeX -> NewHsTypeX Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NewHsTypeX -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NewHsTypeX -> r Source # gmapQ :: (forall d. Data d => d -> u) -> NewHsTypeX -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> NewHsTypeX -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NewHsTypeX -> m NewHsTypeX Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NewHsTypeX -> m NewHsTypeX Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NewHsTypeX -> m NewHsTypeX Source #
Outputable NewHsTypeX #
Instance details Defined in HsTypes Methods ppr :: NewHsTypeX -> SDoc Source # pprPrec :: Rational -> NewHsTypeX -> SDoc Source #

type LHsType pass Source #

Arguments

= Located (HsType pass)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Type

type HsKind pass = HsType pass Source #

Haskell Kind

type LHsKind pass Source #

Arguments

= Located (HsKind pass)

AnnKeywordId : AnnDcolon

Located Haskell Kind

data HsTyVarBndr pass Source #

Haskell Type Variable Binder

Constructors

UserTyVar (XUserTyVar pass) (Located (IdP pass))
KindedTyVar (XKindedTyVar pass) (Located (IdP pass)) (LHsKind pass)	`AnnKeywordId` : `AnnOpen`, `AnnDcolon`, `AnnClose`
XTyVarBndr (XXTyVarBndr pass)

Instances

Data (HsTyVarBndr GhcTc) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyVarBndr GhcTc -> c (HsTyVarBndr GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyVarBndr GhcTc) Source # toConstr :: HsTyVarBndr GhcTc -> Constr Source # dataTypeOf :: HsTyVarBndr GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsTyVarBndr GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsTyVarBndr GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> HsTyVarBndr GhcTc -> HsTyVarBndr GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcTc -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsTyVarBndr GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyVarBndr GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcTc -> m (HsTyVarBndr GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcTc -> m (HsTyVarBndr GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcTc -> m (HsTyVarBndr GhcTc) Source #
Data (HsTyVarBndr GhcRn) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyVarBndr GhcRn -> c (HsTyVarBndr GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyVarBndr GhcRn) Source # toConstr :: HsTyVarBndr GhcRn -> Constr Source # dataTypeOf :: HsTyVarBndr GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsTyVarBndr GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsTyVarBndr GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> HsTyVarBndr GhcRn -> HsTyVarBndr GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcRn -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsTyVarBndr GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyVarBndr GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcRn -> m (HsTyVarBndr GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcRn -> m (HsTyVarBndr GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcRn -> m (HsTyVarBndr GhcRn) Source #
Data (HsTyVarBndr GhcPs) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyVarBndr GhcPs -> c (HsTyVarBndr GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyVarBndr GhcPs) Source # toConstr :: HsTyVarBndr GhcPs -> Constr Source # dataTypeOf :: HsTyVarBndr GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsTyVarBndr GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsTyVarBndr GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> HsTyVarBndr GhcPs -> HsTyVarBndr GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcPs -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsTyVarBndr GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyVarBndr GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcPs -> m (HsTyVarBndr GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcPs -> m (HsTyVarBndr GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr GhcPs -> m (HsTyVarBndr GhcPs) Source #
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsTyVarBndr p) #
Instance details Defined in HsTypes Methods ppr :: HsTyVarBndr p -> SDoc Source # pprPrec :: Rational -> HsTyVarBndr p -> SDoc Source #

type LHsTyVarBndr pass = Located (HsTyVarBndr pass) Source #

Located Haskell Type Variable Binder

data LHsQTyVars pass Source #

Located Haskell Quantified Type Variables

Constructors

HsQTvs
Fields hsq_ext :: XHsQTvs pass hsq_explicit :: [LHsTyVarBndr pass]
XLHsQTyVars (XXLHsQTyVars pass)

Instances

Data (LHsQTyVars GhcTc) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsQTyVars GhcTc -> c (LHsQTyVars GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsQTyVars GhcTc) Source # toConstr :: LHsQTyVars GhcTc -> Constr Source # dataTypeOf :: LHsQTyVars GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsQTyVars GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsQTyVars GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> LHsQTyVars GhcTc -> LHsQTyVars GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcTc -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> LHsQTyVars GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsQTyVars GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcTc -> m (LHsQTyVars GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcTc -> m (LHsQTyVars GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcTc -> m (LHsQTyVars GhcTc) Source #
Data (LHsQTyVars GhcRn) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsQTyVars GhcRn -> c (LHsQTyVars GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsQTyVars GhcRn) Source # toConstr :: LHsQTyVars GhcRn -> Constr Source # dataTypeOf :: LHsQTyVars GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsQTyVars GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsQTyVars GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> LHsQTyVars GhcRn -> LHsQTyVars GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcRn -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> LHsQTyVars GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsQTyVars GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcRn -> m (LHsQTyVars GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcRn -> m (LHsQTyVars GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcRn -> m (LHsQTyVars GhcRn) Source #
Data (LHsQTyVars GhcPs) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsQTyVars GhcPs -> c (LHsQTyVars GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsQTyVars GhcPs) Source # toConstr :: LHsQTyVars GhcPs -> Constr Source # dataTypeOf :: LHsQTyVars GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LHsQTyVars GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LHsQTyVars GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> LHsQTyVars GhcPs -> LHsQTyVars GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcPs -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> LHsQTyVars GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsQTyVars GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcPs -> m (LHsQTyVars GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcPs -> m (LHsQTyVars GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcPs -> m (LHsQTyVars GhcPs) Source #
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (LHsQTyVars p) #
Instance details Defined in HsTypes Methods ppr :: LHsQTyVars p -> SDoc Source # pprPrec :: Rational -> LHsQTyVars p -> SDoc Source #

data HsQTvsRn Source #

Constructors

HsQTvsRn
Fields hsq_implicit :: [Name] hsq_dependent :: NameSet

Instances

Data HsQTvsRn #

Instance details

Defined in HsTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsQTvsRn -> c HsQTvsRn Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsQTvsRn Source #

toConstr :: HsQTvsRn -> Constr Source #

dataTypeOf :: HsQTvsRn -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsQTvsRn) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsQTvsRn) Source #

gmapT :: (forall b. Data b => b -> b) -> HsQTvsRn -> HsQTvsRn Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsQTvsRn -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsQTvsRn -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> HsQTvsRn -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsQTvsRn -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsQTvsRn -> m HsQTvsRn Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQTvsRn -> m HsQTvsRn Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsQTvsRn -> m HsQTvsRn Source #

data HsImplicitBndrs pass thing Source #

Haskell Implicit Binders

Constructors

HsIB
Fields hsib_ext :: XHsIB pass thing hsib_body :: thing
XHsImplicitBndrs (XXHsImplicitBndrs pass thing)

Instances

Data thing => Data (HsImplicitBndrs GhcTc thing) #
Instance details Defined in HsInstances 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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsImplicitBndrs GhcTc thing) Source # toConstr :: HsImplicitBndrs GhcTc thing -> Constr Source # dataTypeOf :: HsImplicitBndrs GhcTc thing -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsImplicitBndrs GhcTc thing)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsImplicitBndrs GhcTc thing)) Source # gmapT :: (forall b. Data b => b -> b) -> HsImplicitBndrs GhcTc thing -> HsImplicitBndrs GhcTc thing Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcTc thing -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcTc thing -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsImplicitBndrs GhcTc thing -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImplicitBndrs GhcTc thing -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcTc thing -> m (HsImplicitBndrs GhcTc thing) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcTc thing -> m (HsImplicitBndrs GhcTc thing) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcTc thing -> m (HsImplicitBndrs GhcTc thing) Source #
Data thing => Data (HsImplicitBndrs GhcRn thing) #
Instance details Defined in HsInstances 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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsImplicitBndrs GhcRn thing) Source # toConstr :: HsImplicitBndrs GhcRn thing -> Constr Source # dataTypeOf :: HsImplicitBndrs GhcRn thing -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsImplicitBndrs GhcRn thing)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsImplicitBndrs GhcRn thing)) Source # gmapT :: (forall b. Data b => b -> b) -> HsImplicitBndrs GhcRn thing -> HsImplicitBndrs GhcRn thing Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcRn thing -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcRn thing -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsImplicitBndrs GhcRn thing -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImplicitBndrs GhcRn thing -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcRn thing -> m (HsImplicitBndrs GhcRn thing) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcRn thing -> m (HsImplicitBndrs GhcRn thing) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcRn thing -> m (HsImplicitBndrs GhcRn thing) Source #
Data thing => Data (HsImplicitBndrs GhcPs thing) #
Instance details Defined in HsInstances 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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsImplicitBndrs GhcPs thing) Source # toConstr :: HsImplicitBndrs GhcPs thing -> Constr Source # dataTypeOf :: HsImplicitBndrs GhcPs thing -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsImplicitBndrs GhcPs thing)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsImplicitBndrs GhcPs thing)) Source # gmapT :: (forall b. Data b => b -> b) -> HsImplicitBndrs GhcPs thing -> HsImplicitBndrs GhcPs thing Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcPs thing -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImplicitBndrs GhcPs thing -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsImplicitBndrs GhcPs thing -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImplicitBndrs GhcPs thing -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcPs thing -> m (HsImplicitBndrs GhcPs thing) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcPs thing -> m (HsImplicitBndrs GhcPs thing) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplicitBndrs GhcPs thing -> m (HsImplicitBndrs GhcPs thing) Source #
(p ~ GhcPass pass, Outputable thing) => Outputable (HsImplicitBndrs p thing) #
Instance details Defined in HsTypes Methods ppr :: HsImplicitBndrs p thing -> SDoc Source # pprPrec :: Rational -> HsImplicitBndrs p thing -> SDoc Source #

data HsIBRn Source #

Constructors

HsIBRn
Fields hsib_vars :: [Name] hsib_closed :: Bool

Instances

Data HsIBRn #

Instance details

Defined in HsTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsIBRn -> c HsIBRn Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsIBRn Source #

toConstr :: HsIBRn -> Constr Source #

dataTypeOf :: HsIBRn -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsIBRn) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsIBRn) Source #

gmapT :: (forall b. Data b => b -> b) -> HsIBRn -> HsIBRn Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsIBRn -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsIBRn -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> HsIBRn -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsIBRn -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsIBRn -> m HsIBRn Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIBRn -> m HsIBRn Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIBRn -> m HsIBRn Source #

data HsWildCardBndrs pass thing Source #

Haskell Wildcard Binders

Constructors

HsWC
Fields hswc_ext :: XHsWC pass thing hswc_body :: thing
XHsWildCardBndrs (XXHsWildCardBndrs pass thing)

Instances

Data thing => Data (HsWildCardBndrs GhcTc thing) #
Instance details Defined in HsInstances 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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsWildCardBndrs GhcTc thing) Source # toConstr :: HsWildCardBndrs GhcTc thing -> Constr Source # dataTypeOf :: HsWildCardBndrs GhcTc thing -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsWildCardBndrs GhcTc thing)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsWildCardBndrs GhcTc thing)) Source # gmapT :: (forall b. Data b => b -> b) -> HsWildCardBndrs GhcTc thing -> HsWildCardBndrs GhcTc thing Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcTc thing -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcTc thing -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsWildCardBndrs GhcTc thing -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsWildCardBndrs GhcTc thing -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcTc thing -> m (HsWildCardBndrs GhcTc thing) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcTc thing -> m (HsWildCardBndrs GhcTc thing) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcTc thing -> m (HsWildCardBndrs GhcTc thing) Source #
Data thing => Data (HsWildCardBndrs GhcRn thing) #
Instance details Defined in HsInstances 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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsWildCardBndrs GhcRn thing) Source # toConstr :: HsWildCardBndrs GhcRn thing -> Constr Source # dataTypeOf :: HsWildCardBndrs GhcRn thing -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsWildCardBndrs GhcRn thing)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsWildCardBndrs GhcRn thing)) Source # gmapT :: (forall b. Data b => b -> b) -> HsWildCardBndrs GhcRn thing -> HsWildCardBndrs GhcRn thing Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcRn thing -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcRn thing -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsWildCardBndrs GhcRn thing -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsWildCardBndrs GhcRn thing -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcRn thing -> m (HsWildCardBndrs GhcRn thing) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcRn thing -> m (HsWildCardBndrs GhcRn thing) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcRn thing -> m (HsWildCardBndrs GhcRn thing) Source #
Data thing => Data (HsWildCardBndrs GhcPs thing) #
Instance details Defined in HsInstances 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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsWildCardBndrs GhcPs thing) Source # toConstr :: HsWildCardBndrs GhcPs thing -> Constr Source # dataTypeOf :: HsWildCardBndrs GhcPs thing -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsWildCardBndrs GhcPs thing)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsWildCardBndrs GhcPs thing)) Source # gmapT :: (forall b. Data b => b -> b) -> HsWildCardBndrs GhcPs thing -> HsWildCardBndrs GhcPs thing Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcPs thing -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcPs thing -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsWildCardBndrs GhcPs thing -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsWildCardBndrs GhcPs thing -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcPs thing -> m (HsWildCardBndrs GhcPs thing) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcPs thing -> m (HsWildCardBndrs GhcPs thing) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcPs thing -> m (HsWildCardBndrs GhcPs thing) Source #
(p ~ GhcPass pass, Outputable thing) => Outputable (HsWildCardBndrs p thing) #
Instance details Defined in HsTypes Methods ppr :: HsWildCardBndrs p thing -> SDoc Source # pprPrec :: Rational -> HsWildCardBndrs p thing -> SDoc Source #

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

Constructors

HsUnboxedTuple
HsBoxedTuple
HsConstraintTuple
HsBoxedOrConstraintTuple

Instances

Data HsTupleSort #

Instance details

Defined in HsTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTupleSort -> c HsTupleSort Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsTupleSort Source #

toConstr :: HsTupleSort -> Constr Source #

dataTypeOf :: HsTupleSort -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsTupleSort) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsTupleSort) Source #

gmapT :: (forall b. Data b => b -> b) -> HsTupleSort -> HsTupleSort Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTupleSort -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTupleSort -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> HsTupleSort -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTupleSort -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort Source #

data Promoted Source #

Promoted data types.

Constructors

Promoted
NotPromoted

Instances

Eq Promoted #
Instance details Defined in HsTypes Methods (==) :: Promoted -> Promoted -> Bool # (/=) :: Promoted -> Promoted -> Bool #
Data Promoted #
Instance details Defined in HsTypes Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Promoted -> c Promoted Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Promoted Source # toConstr :: Promoted -> Constr Source # dataTypeOf :: Promoted -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Promoted) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Promoted) Source # gmapT :: (forall b. Data b => b -> b) -> Promoted -> Promoted Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Promoted -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Promoted -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Promoted -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Promoted -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Promoted -> m Promoted Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Promoted -> m Promoted Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Promoted -> m Promoted Source #
Show Promoted #
Instance details Defined in HsTypes Methods showsPrec :: Int -> Promoted -> ShowS Source # show :: Promoted -> String Source # showList :: [Promoted] -> ShowS Source #

type HsContext pass = [LHsType pass] Source #

Haskell Context

type LHsContext pass Source #

Arguments

= Located (HsContext pass)

AnnKeywordId : AnnUnit

Located Haskell Context

data HsTyLit Source #

Haskell Type Literal

Constructors

HsNumTy SourceText Integer
HsStrTy SourceText FastString

Instances

Data HsTyLit #
Instance details Defined in HsTypes Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyLit -> c HsTyLit Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsTyLit Source # toConstr :: HsTyLit -> Constr Source # dataTypeOf :: HsTyLit -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsTyLit) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsTyLit) Source # gmapT :: (forall b. Data b => b -> b) -> HsTyLit -> HsTyLit Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsTyLit -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyLit -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyLit -> m HsTyLit Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit -> m HsTyLit Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit -> m HsTyLit Source #
Outputable HsTyLit #
Instance details Defined in HsTypes Methods ppr :: HsTyLit -> SDoc Source # pprPrec :: Rational -> HsTyLit -> SDoc Source #

newtype HsIPName 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 #
Instance details Defined in HsTypes Methods (==) :: HsIPName -> HsIPName -> Bool # (/=) :: HsIPName -> HsIPName -> Bool #
Data HsIPName #
Instance details Defined in HsTypes Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsIPName -> c HsIPName Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsIPName Source # toConstr :: HsIPName -> Constr Source # dataTypeOf :: HsIPName -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsIPName) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsIPName) Source # gmapT :: (forall b. Data b => b -> b) -> HsIPName -> HsIPName Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsIPName -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsIPName -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsIPName -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsIPName -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName Source #
OutputableBndr HsIPName #
Instance details Defined in HsTypes Methods pprBndr :: BindingSite -> HsIPName -> SDoc Source # pprPrefixOcc :: HsIPName -> SDoc Source # pprInfixOcc :: HsIPName -> SDoc Source # bndrIsJoin_maybe :: HsIPName -> Maybe Int Source #
Outputable HsIPName #
Instance details Defined in HsTypes Methods ppr :: HsIPName -> SDoc Source # pprPrec :: Rational -> HsIPName -> SDoc Source #

hsIPNameFS :: HsIPName -> FastString Source #

type LBangType pass = Located (BangType pass) Source #

Located Bang Type

type BangType pass = HsType pass Source #

Bang Type

data HsSrcBang Source #

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 #
Instance details Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSrcBang -> c HsSrcBang Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsSrcBang Source # toConstr :: HsSrcBang -> Constr Source # dataTypeOf :: HsSrcBang -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsSrcBang) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSrcBang) Source # gmapT :: (forall b. Data b => b -> b) -> HsSrcBang -> HsSrcBang Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsSrcBang -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSrcBang -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang Source #
Outputable HsSrcBang #
Instance details Defined in DataCon Methods ppr :: HsSrcBang -> SDoc Source # pprPrec :: Rational -> HsSrcBang -> SDoc 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 #
Instance details Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImplBang -> c HsImplBang Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsImplBang Source # toConstr :: HsImplBang -> Constr Source # dataTypeOf :: HsImplBang -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsImplBang) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsImplBang) Source # gmapT :: (forall b. Data b => b -> b) -> HsImplBang -> HsImplBang Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImplBang -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImplBang -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsImplBang -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImplBang -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang Source #
Outputable HsImplBang #
Instance details Defined in DataCon Methods ppr :: HsImplBang -> SDoc Source # pprPrec :: Rational -> HsImplBang -> SDoc 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 #
Instance details Defined in DataCon Methods (==) :: SrcStrictness -> SrcStrictness -> Bool # (/=) :: SrcStrictness -> SrcStrictness -> Bool #
Data SrcStrictness #
Instance details Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcStrictness -> c SrcStrictness Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcStrictness Source # toConstr :: SrcStrictness -> Constr Source # dataTypeOf :: SrcStrictness -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcStrictness) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcStrictness) Source # gmapT :: (forall b. Data b => b -> b) -> SrcStrictness -> SrcStrictness Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SrcStrictness -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcStrictness -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness Source #
Outputable SrcStrictness #
Instance details Defined in DataCon Methods ppr :: SrcStrictness -> SDoc Source # pprPrec :: Rational -> SrcStrictness -> SDoc Source #
Binary SrcStrictness #
Instance details Defined in DataCon Methods put_ :: BinHandle -> SrcStrictness -> IO () Source # put :: BinHandle -> SrcStrictness -> IO (Bin SrcStrictness) Source # get :: BinHandle -> IO SrcStrictness Source #

data SrcUnpackedness Source #

Source Unpackedness

What unpackedness the user requested

Constructors

SrcUnpack	{--} specified
SrcNoUnpack	{--} specified
NoSrcUnpack	no unpack pragma

Instances

Eq SrcUnpackedness #
Instance details Defined in DataCon Methods (==) :: SrcUnpackedness -> SrcUnpackedness -> Bool # (/=) :: SrcUnpackedness -> SrcUnpackedness -> Bool #
Data SrcUnpackedness #
Instance details Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcUnpackedness -> c SrcUnpackedness Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcUnpackedness Source # toConstr :: SrcUnpackedness -> Constr Source # dataTypeOf :: SrcUnpackedness -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcUnpackedness) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcUnpackedness) Source # gmapT :: (forall b. Data b => b -> b) -> SrcUnpackedness -> SrcUnpackedness Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SrcUnpackedness -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcUnpackedness -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness Source #
Outputable SrcUnpackedness #
Instance details Defined in DataCon Methods ppr :: SrcUnpackedness -> SDoc Source # pprPrec :: Rational -> SrcUnpackedness -> SDoc Source #
Binary SrcUnpackedness #
Instance details Defined in DataCon Methods put_ :: BinHandle -> SrcUnpackedness -> IO () Source # put :: BinHandle -> SrcUnpackedness -> IO (Bin SrcUnpackedness) Source # get :: BinHandle -> IO SrcUnpackedness Source #

getBangType :: LHsType a -> LHsType a Source #

getBangStrictness :: LHsType a -> HsSrcBang Source #

data ConDeclField pass Source #

Constructor Declaration Field

Constructors

ConDeclField	`AnnKeywordId` : `AnnDcolon`
Fields cd_fld_ext :: XConDeclField pass cd_fld_names :: [LFieldOcc pass] See Note [ConDeclField passs] cd_fld_type :: LBangType pass cd_fld_doc :: Maybe LHsDocString
XConDeclField (XXConDeclField pass)

Instances

Data (ConDeclField GhcTc) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDeclField GhcTc -> c (ConDeclField GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDeclField GhcTc) Source # toConstr :: ConDeclField GhcTc -> Constr Source # dataTypeOf :: ConDeclField GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDeclField GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDeclField GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> ConDeclField GhcTc -> ConDeclField GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcTc -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ConDeclField GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDeclField GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDeclField GhcTc -> m (ConDeclField GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcTc -> m (ConDeclField GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcTc -> m (ConDeclField GhcTc) Source #
Data (ConDeclField GhcRn) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDeclField GhcRn -> c (ConDeclField GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDeclField GhcRn) Source # toConstr :: ConDeclField GhcRn -> Constr Source # dataTypeOf :: ConDeclField GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDeclField GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDeclField GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> ConDeclField GhcRn -> ConDeclField GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcRn -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ConDeclField GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDeclField GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDeclField GhcRn -> m (ConDeclField GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcRn -> m (ConDeclField GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcRn -> m (ConDeclField GhcRn) Source #
Data (ConDeclField GhcPs) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDeclField GhcPs -> c (ConDeclField GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDeclField GhcPs) Source # toConstr :: ConDeclField GhcPs -> Constr Source # dataTypeOf :: ConDeclField GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDeclField GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDeclField GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> ConDeclField GhcPs -> ConDeclField GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcPs -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDeclField GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> ConDeclField GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDeclField GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDeclField GhcPs -> m (ConDeclField GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcPs -> m (ConDeclField GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDeclField GhcPs -> m (ConDeclField GhcPs) Source #
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ConDeclField p) #
Instance details Defined in HsTypes Methods ppr :: ConDeclField p -> SDoc Source # pprPrec :: Rational -> ConDeclField p -> SDoc Source #

type LConDeclField pass Source #

Arguments

= Located (ConDeclField pass)

May have AnnKeywordId : AnnComma when in a list

Located Constructor Declaration Field

pprConDeclFields :: OutputableBndrId (GhcPass p) => [LConDeclField (GhcPass p)] -> SDoc Source #

data HsConDetails arg rec Source #

Haskell Constructor Details

Constructors

PrefixCon [arg]
RecCon rec
InfixCon arg arg

Instances

(Data arg, Data rec) => Data (HsConDetails arg rec) #
Instance details Defined in HsTypes 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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDetails arg rec) Source # toConstr :: HsConDetails arg rec -> Constr Source # dataTypeOf :: HsConDetails arg rec -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDetails arg rec)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDetails arg rec)) Source # gmapT :: (forall b. Data b => b -> b) -> HsConDetails arg rec -> HsConDetails arg rec Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsConDetails arg rec -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDetails arg rec -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) Source #
(Outputable arg, Outputable rec) => Outputable (HsConDetails arg rec) #
Instance details Defined in HsTypes Methods ppr :: HsConDetails arg rec -> SDoc Source # pprPrec :: Rational -> HsConDetails arg rec -> SDoc Source #

data FieldOcc pass Source #

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 extFieldOcc :: XCFieldOcc pass rdrNameFieldOcc :: Located RdrName See Note [Located RdrNames] in HsExpr
XFieldOcc (XXFieldOcc pass)

Instances

(p ~ GhcPass pass, Eq (XCFieldOcc p)) => Eq (FieldOcc p) #
Instance details Defined in HsTypes Methods (==) :: FieldOcc p -> FieldOcc p -> Bool # (/=) :: FieldOcc p -> FieldOcc p -> Bool #
Data (FieldOcc GhcTc) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldOcc GhcTc -> c (FieldOcc GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldOcc GhcTc) Source # toConstr :: FieldOcc GhcTc -> Constr Source # dataTypeOf :: FieldOcc GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldOcc GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldOcc GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> FieldOcc GhcTc -> FieldOcc GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcTc -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FieldOcc GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldOcc GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldOcc GhcTc -> m (FieldOcc GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcTc -> m (FieldOcc GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcTc -> m (FieldOcc GhcTc) Source #
Data (FieldOcc GhcRn) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldOcc GhcRn -> c (FieldOcc GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldOcc GhcRn) Source # toConstr :: FieldOcc GhcRn -> Constr Source # dataTypeOf :: FieldOcc GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldOcc GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldOcc GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> FieldOcc GhcRn -> FieldOcc GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcRn -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FieldOcc GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldOcc GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldOcc GhcRn -> m (FieldOcc GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcRn -> m (FieldOcc GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcRn -> m (FieldOcc GhcRn) Source #
Data (FieldOcc GhcPs) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldOcc GhcPs -> c (FieldOcc GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldOcc GhcPs) Source # toConstr :: FieldOcc GhcPs -> Constr Source # dataTypeOf :: FieldOcc GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldOcc GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldOcc GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> FieldOcc GhcPs -> FieldOcc GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcPs -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FieldOcc GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldOcc GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldOcc GhcPs -> m (FieldOcc GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcPs -> m (FieldOcc GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcPs -> m (FieldOcc GhcPs) Source #
(p ~ GhcPass pass, Ord (XCFieldOcc p)) => Ord (FieldOcc p) #
Instance details Defined in HsTypes Methods compare :: FieldOcc p -> FieldOcc p -> Ordering # (<) :: FieldOcc p -> FieldOcc p -> Bool # (<=) :: FieldOcc p -> FieldOcc p -> Bool # (>) :: FieldOcc p -> FieldOcc p -> Bool # (>=) :: FieldOcc p -> FieldOcc p -> Bool # max :: FieldOcc p -> FieldOcc p -> FieldOcc p # min :: FieldOcc p -> FieldOcc p -> FieldOcc p #
Outputable (FieldOcc pass) #
Instance details Defined in HsTypes Methods ppr :: FieldOcc pass -> SDoc Source # pprPrec :: Rational -> FieldOcc pass -> SDoc Source #

type LFieldOcc pass = Located (FieldOcc pass) Source #

Located Field Occurrence

mkFieldOcc :: Located RdrName -> FieldOcc GhcPs 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 HsPat and Note [Disambiguating record fields] in TcExpr. See Note [Located RdrNames] in HsExpr

Constructors

Unambiguous (XUnambiguous pass) (Located RdrName)
Ambiguous (XAmbiguous pass) (Located RdrName)
XAmbiguousFieldOcc (XXAmbiguousFieldOcc pass)

Instances

Data (AmbiguousFieldOcc GhcTc) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AmbiguousFieldOcc GhcTc -> c (AmbiguousFieldOcc GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AmbiguousFieldOcc GhcTc) Source # toConstr :: AmbiguousFieldOcc GhcTc -> Constr Source # dataTypeOf :: AmbiguousFieldOcc GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AmbiguousFieldOcc GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AmbiguousFieldOcc GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> AmbiguousFieldOcc GhcTc -> AmbiguousFieldOcc GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcTc -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcTc -> m (AmbiguousFieldOcc GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcTc -> m (AmbiguousFieldOcc GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcTc -> m (AmbiguousFieldOcc GhcTc) Source #
Data (AmbiguousFieldOcc GhcRn) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AmbiguousFieldOcc GhcRn -> c (AmbiguousFieldOcc GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AmbiguousFieldOcc GhcRn) Source # toConstr :: AmbiguousFieldOcc GhcRn -> Constr Source # dataTypeOf :: AmbiguousFieldOcc GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AmbiguousFieldOcc GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AmbiguousFieldOcc GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> AmbiguousFieldOcc GhcRn -> AmbiguousFieldOcc GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcRn -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcRn -> m (AmbiguousFieldOcc GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcRn -> m (AmbiguousFieldOcc GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcRn -> m (AmbiguousFieldOcc GhcRn) Source #
Data (AmbiguousFieldOcc GhcPs) #
Instance details Defined in HsInstances Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AmbiguousFieldOcc GhcPs -> c (AmbiguousFieldOcc GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AmbiguousFieldOcc GhcPs) Source # toConstr :: AmbiguousFieldOcc GhcPs -> Constr Source # dataTypeOf :: AmbiguousFieldOcc GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AmbiguousFieldOcc GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AmbiguousFieldOcc GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> AmbiguousFieldOcc GhcPs -> AmbiguousFieldOcc GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcPs -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AmbiguousFieldOcc GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> AmbiguousFieldOcc GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcPs -> m (AmbiguousFieldOcc GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcPs -> m (AmbiguousFieldOcc GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AmbiguousFieldOcc GhcPs -> m (AmbiguousFieldOcc GhcPs) Source #
p ~ GhcPass pass => OutputableBndr (AmbiguousFieldOcc p) #
Instance details Defined in HsTypes Methods pprBndr :: BindingSite -> AmbiguousFieldOcc p -> SDoc Source # pprPrefixOcc :: AmbiguousFieldOcc p -> SDoc Source # pprInfixOcc :: AmbiguousFieldOcc p -> SDoc Source # bndrIsJoin_maybe :: AmbiguousFieldOcc p -> Maybe Int Source #
p ~ GhcPass pass => Outputable (AmbiguousFieldOcc p) #
Instance details Defined in HsTypes Methods ppr :: AmbiguousFieldOcc p -> SDoc Source # pprPrec :: Rational -> AmbiguousFieldOcc p -> SDoc Source #

mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc GhcPs Source #

rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc (GhcPass p) -> RdrName Source #

selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id Source #

unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc Source #

ambiguousFieldOcc :: FieldOcc GhcTc -> AmbiguousFieldOcc GhcTc Source #

newtype HsWildCardInfo Source #

Constructors

AnonWildCard (Located Name)

Instances

Data HsWildCardInfo #
Instance details Defined in HsTypes Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsWildCardInfo -> c HsWildCardInfo Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsWildCardInfo Source # toConstr :: HsWildCardInfo -> Constr Source # dataTypeOf :: HsWildCardInfo -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsWildCardInfo) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsWildCardInfo) Source # gmapT :: (forall b. Data b => b -> b) -> HsWildCardInfo -> HsWildCardInfo Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardInfo -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardInfo -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsWildCardInfo -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsWildCardInfo -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsWildCardInfo -> m HsWildCardInfo Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardInfo -> m HsWildCardInfo Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardInfo -> m HsWildCardInfo Source #
Outputable HsWildCardInfo #
Instance details Defined in HsTypes Methods ppr :: HsWildCardInfo -> SDoc Source # pprPrec :: Rational -> HsWildCardInfo -> SDoc Source #

mkAnonWildCardTy :: HsType GhcPs Source #

pprAnonWildCard :: SDoc Source #

wildCardName :: HsWildCardInfo -> Name Source #

sameWildCard :: Located HsWildCardInfo -> Located HsWildCardInfo -> Bool Source #

mkHsImplicitBndrs :: thing -> HsImplicitBndrs GhcPs thing Source #

mkHsWildCardBndrs :: thing -> HsWildCardBndrs GhcPs thing Source #

hsImplicitBody :: HsImplicitBndrs pass 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 #

emptyLHsQTvs :: LHsQTyVars GhcRn 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 pass -> IdP pass Source #

hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name] Source #

hsLTyVarLocNames :: LHsQTyVars pass -> [Located (IdP pass)] Source #

hsLTyVarName :: LHsTyVarBndr pass -> IdP pass Source #

hsLTyVarLocName :: LHsTyVarBndr pass -> Located (IdP pass) Source #

hsExplicitLTyVarNames :: LHsQTyVars pass -> [IdP pass] Source #

splitLHsInstDeclTy :: LHsSigType GhcRn -> ([Name], LHsContext GhcRn, LHsType GhcRn) Source #

getLHsInstDeclHead :: LHsSigType pass -> LHsType pass 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 #

splitLHsForAllTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsType pass) Source #

splitLHsQualTy :: LHsType pass -> (LHsContext pass, LHsType pass) Source #

splitLHsSigmaTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, LHsType pass) Source #

splitHsFunType :: LHsType GhcRn -> ([LHsType GhcRn], LHsType GhcRn) Source #

splitHsAppTys :: LHsType GhcRn -> [LHsType GhcRn] -> (LHsType GhcRn, [LHsType GhcRn]) Source #

hsTyGetAppHead_maybe :: LHsType (GhcPass p) -> Maybe (Located (IdP (GhcPass p)), [LHsType (GhcPass p)]) Source #

mkHsOpTy :: LHsType (GhcPass p) -> Located (IdP (GhcPass p)) -> LHsType (GhcPass p) -> HsType (GhcPass p) Source #

mkHsAppTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) Source #

mkHsAppTys :: LHsType (GhcPass p) -> [LHsType (GhcPass p)] -> LHsType (GhcPass p) Source #

ignoreParens :: LHsType pass -> LHsType pass Source #

hsSigType :: LHsSigType 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.

pprHsType :: OutputableBndrId (GhcPass p) => HsType (GhcPass p) -> SDoc Source #

pprHsForAll :: OutputableBndrId (GhcPass p) => [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc Source #

pprHsForAllTvs :: OutputableBndrId (GhcPass p) => [LHsTyVarBndr (GhcPass p)] -> SDoc Source #

pprHsForAllExtra :: OutputableBndrId (GhcPass p) => Maybe SrcSpan -> [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.

pprHsContext :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> SDoc Source #

pprHsContextNoArrow :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> SDoc Source #

pprHsContextMaybe :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> Maybe SDoc Source #

hsTypeNeedsParens :: PprPrec -> HsType pass -> Bool Source #

hsTypeNeedsParens p t returns True if the type t needs parentheses under precedence p.

parenthesizeHsType :: PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p) Source #

parenthesizeHsType p ty checks if hsTypeNeedsParens p ty is true, and if so, surrounds ty with an HsParTy. Otherwise, it simply returns ty.