Safe Haskell	None
Language	Haskell2010

HsTypes

Synopsis

data HsType pass
- = HsForAllTy {
  - hst_bndrs :: [LHsTyVarBndr pass]
  - hst_body :: LHsType pass
  }
- | HsQualTy {
  - hst_ctxt :: LHsContext pass
  - hst_body :: LHsType pass
  }
- | HsTyVar Promoted (Located (IdP pass))
- | HsAppsTy [LHsAppType pass]
- | HsAppTy (LHsType pass) (LHsType pass)
- | HsFunTy (LHsType pass) (LHsType pass)
- | HsListTy (LHsType pass)
- | HsPArrTy (LHsType pass)
- | HsTupleTy HsTupleSort [LHsType pass]
- | HsSumTy [LHsType pass]
- | HsOpTy (LHsType pass) (Located (IdP pass)) (LHsType pass)
- | HsParTy (LHsType pass)
- | HsIParamTy (Located HsIPName) (LHsType pass)
- | HsEqTy (LHsType pass) (LHsType pass)
- | HsKindSig (LHsType pass) (LHsKind pass)
- | HsSpliceTy (HsSplice pass) (PostTc pass Kind)
- | HsDocTy (LHsType pass) LHsDocString
- | HsBangTy HsSrcBang (LHsType pass)
- | HsRecTy [LConDeclField pass]
- | HsCoreTy Type
- | HsExplicitListTy Promoted (PostTc pass Kind) [LHsType pass]
- | HsExplicitTupleTy [PostTc pass Kind] [LHsType pass]
- | HsTyLit HsTyLit
- | HsWildCardTy (HsWildCardInfo pass)
type LHsType pass = Located (HsType pass)
type HsKind pass = HsType pass
type LHsKind pass = Located (HsKind pass)
data HsTyVarBndr pass
- = UserTyVar (Located (IdP pass))
- | KindedTyVar (Located (IdP pass)) (LHsKind pass)
type LHsTyVarBndr pass = Located (HsTyVarBndr pass)
data LHsQTyVars pass = HsQTvs {
- hsq_implicit :: PostRn pass [Name]
- hsq_explicit :: [LHsTyVarBndr pass]
- hsq_dependent :: PostRn pass NameSet
}
data HsImplicitBndrs pass thing = HsIB {
- hsib_vars :: PostRn pass [Name]
- hsib_body :: thing
- hsib_closed :: PostRn pass Bool
}
data HsWildCardBndrs pass thing = HsWC {
- hswc_wcs :: PostRn pass [Name]
- hswc_body :: 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
data HsAppType pass
- = HsAppInfix (Located (IdP pass))
- | HsAppPrefix (LHsType pass)
type LHsAppType pass = Located (HsAppType pass)
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_names :: [LFieldOcc pass]
- cd_fld_type :: LBangType pass
- cd_fld_doc :: Maybe LHsDocString
}
type LConDeclField pass = Located (ConDeclField pass)
pprConDeclFields :: (SourceTextX pass, OutputableBndrId pass) => [LConDeclField pass] -> SDoc
updateGadtResult :: Monad m => (SDoc -> m ()) -> SDoc -> HsConDetails (LHsType GhcRn) (Located [LConDeclField GhcRn]) -> LHsType GhcRn -> m (HsConDetails (LHsType GhcRn) (Located [LConDeclField GhcRn]), LHsType GhcRn)
data HsConDetails arg rec
- = PrefixCon [arg]
- | RecCon rec
- | InfixCon arg arg
data FieldOcc pass = FieldOcc {
- rdrNameFieldOcc :: Located RdrName
- selectorFieldOcc :: PostRn pass (IdP pass)
}
type LFieldOcc pass = Located (FieldOcc pass)
mkFieldOcc :: Located RdrName -> FieldOcc GhcPs
data AmbiguousFieldOcc pass
- = Unambiguous (Located RdrName) (PostRn pass (IdP pass))
- | Ambiguous (Located RdrName) (PostTc pass (IdP pass))
mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc GhcPs
rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc pass -> RdrName
selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id
unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc
ambiguousFieldOcc :: FieldOcc pass -> AmbiguousFieldOcc pass
newtype HsWildCardInfo pass = AnonWildCard (PostRn pass (Located Name))
mkAnonWildCardTy :: HsType GhcPs
wildCardName :: HsWildCardInfo GhcRn -> Name
sameWildCard :: Located (HsWildCardInfo pass) -> Located (HsWildCardInfo pass) -> 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
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 pass -> Maybe (Located (IdP pass))
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)
splitHsAppsTy :: [LHsAppType pass] -> ([[LHsType pass]], [Located (IdP pass)])
splitHsAppTys :: LHsType GhcRn -> [LHsType GhcRn] -> (LHsType GhcRn, [LHsType GhcRn])
getAppsTyHead_maybe :: [LHsAppType pass] -> Maybe (LHsType pass, [LHsType pass], LexicalFixity)
hsTyGetAppHead_maybe :: LHsType pass -> Maybe (Located (IdP pass), [LHsType pass])
mkHsOpTy :: LHsType pass -> Located (IdP pass) -> LHsType pass -> HsType pass
mkHsAppTy :: LHsType pass -> LHsType pass -> LHsType pass
mkHsAppTys :: LHsType pass -> [LHsType pass] -> LHsType pass
ignoreParens :: LHsType pass -> LHsType pass
hsSigType :: LHsSigType pass -> LHsType pass
hsSigWcType :: LHsSigWcType pass -> LHsType pass
hsLTyVarBndrToType :: LHsTyVarBndr pass -> LHsType pass
hsLTyVarBndrsToTypes :: LHsQTyVars pass -> [LHsType pass]
pprHsType :: (SourceTextX pass, OutputableBndrId pass) => HsType pass -> SDoc
pprHsForAll :: (SourceTextX pass, OutputableBndrId pass) => [LHsTyVarBndr pass] -> LHsContext pass -> SDoc
pprHsForAllTvs :: (SourceTextX pass, OutputableBndrId pass) => [LHsTyVarBndr pass] -> SDoc
pprHsForAllExtra :: (SourceTextX pass, OutputableBndrId pass) => Maybe SrcSpan -> [LHsTyVarBndr pass] -> LHsContext pass -> SDoc
pprHsContext :: (SourceTextX pass, OutputableBndrId pass) => HsContext pass -> SDoc
pprHsContextNoArrow :: (SourceTextX pass, OutputableBndrId pass) => HsContext pass -> SDoc
pprHsContextMaybe :: (SourceTextX pass, OutputableBndrId pass) => HsContext pass -> Maybe SDoc
isCompoundHsType :: LHsType pass -> Bool
parenthesizeCompoundHsType :: LHsType pass -> LHsType pass

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_bndrs :: [LHsTyVarBndr pass] hst_body :: LHsType pass
HsQualTy
Fields hst_ctxt :: LHsContext pass hst_body :: LHsType pass
HsTyVar Promoted (Located (IdP pass))	`AnnKeywordId` : None
HsAppsTy [LHsAppType pass]	`AnnKeywordId` : None
HsAppTy (LHsType pass) (LHsType pass)	`AnnKeywordId` : None
HsFunTy (LHsType pass) (LHsType pass)	`AnnKeywordId` : `AnnRarrow`,
HsListTy (LHsType pass)	`AnnKeywordId` : `AnnOpen` `'['`, `AnnClose` `']'`
HsPArrTy (LHsType pass)	`AnnKeywordId` : `AnnOpen` `'[:'`, `AnnClose` `':]'`
HsTupleTy HsTupleSort [LHsType pass]	`AnnKeywordId` : `AnnOpen` `'(' or '(#'`, `AnnClose` `')' or '#)'`
HsSumTy [LHsType pass]	`AnnKeywordId` : `AnnOpen` `'(#'`, `AnnClose` '#)'@
HsOpTy (LHsType pass) (Located (IdP pass)) (LHsType pass)	`AnnKeywordId` : None
HsParTy (LHsType pass)	`AnnKeywordId` : `AnnOpen` `'('`, `AnnClose` `')'`
HsIParamTy (Located HsIPName) (LHsType pass)	(?x :: ty) `AnnKeywordId` : `AnnDcolon`
HsEqTy (LHsType pass) (LHsType pass)	ty1 ~ ty2 `AnnKeywordId` : `AnnTilde`
HsKindSig (LHsType pass) (LHsKind pass)	(ty :: kind) `AnnKeywordId` : `AnnOpen` `'('`, `AnnDcolon`,`AnnClose` `')'`
HsSpliceTy (HsSplice pass) (PostTc pass Kind)	`AnnKeywordId` : `AnnOpen` `'$('`, `AnnClose` `')'`
HsDocTy (LHsType pass) LHsDocString	`AnnKeywordId` : None
HsBangTy HsSrcBang (LHsType pass)	`AnnKeywordId` : `AnnOpen` `'{-# UNPACK' or '{-# NOUNPACK'`, `AnnClose` `'#-}'` `AnnBang` `'!'`
HsRecTy [LConDeclField pass]	`AnnKeywordId` : `AnnOpen` `'{'`, `AnnClose` `'}'`
HsCoreTy Type	`AnnKeywordId` : None
HsExplicitListTy Promoted (PostTc pass Kind) [LHsType pass]	`AnnKeywordId` : `AnnOpen` `"'["`, `AnnClose` `']'`
HsExplicitTupleTy [PostTc pass Kind] [LHsType pass]	`AnnKeywordId` : `AnnOpen` `"'("`, `AnnClose` `')'`
HsTyLit HsTyLit	`AnnKeywordId` : None
HsWildCardTy (HsWildCardInfo pass)	`AnnKeywordId` : None

Instances

DataId pass => Data (HsType pass) #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType pass -> c (HsType pass) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsType pass) Source # toConstr :: HsType pass -> Constr Source # dataTypeOf :: HsType pass -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsType pass)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsType pass)) Source # gmapT :: (forall b. Data b => b -> b) -> HsType pass -> HsType pass Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType pass -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType pass -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsType pass -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType pass -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType pass -> m (HsType pass) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType pass -> m (HsType pass) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType pass -> m (HsType pass) Source #
(SourceTextX pass, OutputableBndrId pass) => Outputable (HsType pass) #
Instance details Methods ppr :: HsType pass -> SDoc Source # pprPrec :: Rational -> HsType pass -> 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 (Located (IdP pass))
KindedTyVar (Located (IdP pass)) (LHsKind pass)	`AnnKeywordId` : `AnnOpen`, `AnnDcolon`, `AnnClose`

Instances

DataId pass => Data (HsTyVarBndr pass) #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyVarBndr pass -> c (HsTyVarBndr pass) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyVarBndr pass) Source # toConstr :: HsTyVarBndr pass -> Constr Source # dataTypeOf :: HsTyVarBndr pass -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsTyVarBndr pass)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsTyVarBndr pass)) Source # gmapT :: (forall b. Data b => b -> b) -> HsTyVarBndr pass -> HsTyVarBndr pass Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr pass -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr pass -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsTyVarBndr pass -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyVarBndr pass -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyVarBndr pass -> m (HsTyVarBndr pass) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr pass -> m (HsTyVarBndr pass) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr pass -> m (HsTyVarBndr pass) Source #
(SourceTextX pass, OutputableBndrId pass) => Outputable (HsTyVarBndr pass) #
Instance details Methods ppr :: HsTyVarBndr pass -> SDoc Source # pprPrec :: Rational -> HsTyVarBndr pass -> 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_implicit :: PostRn pass [Name] hsq_explicit :: [LHsTyVarBndr pass] hsq_dependent :: PostRn pass NameSet

Instances

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

data HsImplicitBndrs pass thing Source #

Haskell Implicit Binders

Constructors

HsIB
Fields hsib_vars :: PostRn pass [Name] hsib_body :: thing hsib_closed :: PostRn pass Bool

Instances

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

data HsWildCardBndrs pass thing Source #

Haskell Wildcard Binders

Constructors

HsWC
Fields hswc_wcs :: PostRn pass [Name] hswc_body :: thing

Instances

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

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 Methods (==) :: Promoted -> Promoted -> Bool # (/=) :: Promoted -> Promoted -> Bool #
Data Promoted #
Instance details 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 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 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 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 Methods (==) :: HsIPName -> HsIPName -> Bool # (/=) :: HsIPName -> HsIPName -> Bool #
Data HsIPName #
Instance details 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 Methods pprBndr :: BindingSite -> HsIPName -> SDoc Source # pprPrefixOcc :: HsIPName -> SDoc Source # pprInfixOcc :: HsIPName -> SDoc Source # bndrIsJoin_maybe :: HsIPName -> Maybe Int Source #
Outputable HsIPName #
Instance details Methods ppr :: HsIPName -> SDoc Source # pprPrec :: Rational -> HsIPName -> SDoc Source #

hsIPNameFS :: HsIPName -> FastString Source #

data HsAppType pass Source #

Haskell Application Type

Constructors

HsAppInfix (Located (IdP pass))
HsAppPrefix (LHsType pass)

Instances

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

type LHsAppType pass Source #

Arguments

= Located (HsAppType pass)

AnnKeywordId : AnnSimpleQuote

Located Haskell Application Type

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 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 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 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 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 Methods (==) :: SrcStrictness -> SrcStrictness -> Bool # (/=) :: SrcStrictness -> SrcStrictness -> Bool #
Data SrcStrictness #
Instance details 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 Methods ppr :: SrcStrictness -> SDoc Source # pprPrec :: Rational -> SrcStrictness -> SDoc Source #
Binary SrcStrictness #
Instance details 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 Methods (==) :: SrcUnpackedness -> SrcUnpackedness -> Bool # (/=) :: SrcUnpackedness -> SrcUnpackedness -> Bool #
Data SrcUnpackedness #
Instance details 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 Methods ppr :: SrcUnpackedness -> SDoc Source # pprPrec :: Rational -> SrcUnpackedness -> SDoc Source #
Binary SrcUnpackedness #
Instance details 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_names :: [LFieldOcc pass] See Note [ConDeclField passs] cd_fld_type :: LBangType pass cd_fld_doc :: Maybe LHsDocString

Instances

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

type LConDeclField pass Source #

Arguments

= Located (ConDeclField pass)

May have AnnKeywordId : AnnComma when in a list

Located Constructor Declaration Field

pprConDeclFields :: (SourceTextX pass, OutputableBndrId pass) => [LConDeclField pass] -> SDoc Source #

updateGadtResult Source #

Arguments

:: Monad m
=> (SDoc -> m ())
-> SDoc
-> HsConDetails (LHsType GhcRn) (Located [LConDeclField GhcRn])	Original details
-> LHsType GhcRn	Original result type
-> m (HsConDetails (LHsType GhcRn) (Located [LConDeclField GhcRn]), LHsType GhcRn)

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 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 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 rdrNameFieldOcc :: Located RdrName See Note [Located RdrNames] in HsExpr selectorFieldOcc :: PostRn pass (IdP pass)

Instances

Eq (PostRn pass (IdP pass)) => Eq (FieldOcc pass) #
Instance details Methods (==) :: FieldOcc pass -> FieldOcc pass -> Bool # (/=) :: FieldOcc pass -> FieldOcc pass -> Bool #
DataId pass => Data (FieldOcc pass) #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldOcc pass -> c (FieldOcc pass) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldOcc pass) Source # toConstr :: FieldOcc pass -> Constr Source # dataTypeOf :: FieldOcc pass -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldOcc pass)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldOcc pass)) Source # gmapT :: (forall b. Data b => b -> b) -> FieldOcc pass -> FieldOcc pass Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc pass -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc pass -> r Source # gmapQ :: (forall d. Data d => d -> u) -> FieldOcc pass -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldOcc pass -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldOcc pass -> m (FieldOcc pass) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc pass -> m (FieldOcc pass) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc pass -> m (FieldOcc pass) Source #
Ord (PostRn pass (IdP pass)) => Ord (FieldOcc pass) #
Instance details Methods compare :: FieldOcc pass -> FieldOcc pass -> Ordering # (<) :: FieldOcc pass -> FieldOcc pass -> Bool # (<=) :: FieldOcc pass -> FieldOcc pass -> Bool # (>) :: FieldOcc pass -> FieldOcc pass -> Bool # (>=) :: FieldOcc pass -> FieldOcc pass -> Bool # max :: FieldOcc pass -> FieldOcc pass -> FieldOcc pass # min :: FieldOcc pass -> FieldOcc pass -> FieldOcc pass #
Outputable (FieldOcc pass) #
Instance details 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 (Located RdrName) (PostRn pass (IdP pass))
Ambiguous (Located RdrName) (PostTc pass (IdP pass))

Instances

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

mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc GhcPs Source #

rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc pass -> RdrName Source #

selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id Source #

unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc Source #

ambiguousFieldOcc :: FieldOcc pass -> AmbiguousFieldOcc pass Source #

newtype HsWildCardInfo pass Source #

Constructors

AnonWildCard (PostRn pass (Located Name))

Instances

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

mkAnonWildCardTy :: HsType GhcPs Source #

wildCardName :: HsWildCardInfo GhcRn -> Name Source #

sameWildCard :: Located (HsWildCardInfo pass) -> Located (HsWildCardInfo pass) -> 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?

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 pass -> Maybe (Located (IdP pass)) 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 #

splitHsAppsTy :: [LHsAppType pass] -> ([[LHsType pass]], [Located (IdP pass)]) Source #

Splits a [HsAppType pass] (the payload of an HsAppsTy) into regions of prefix types (normal types) and infix operators. If splitHsAppsTy tys = (non_syms, syms), then tys starts with the first element of non_syms followed by the first element of syms followed by the next element of non_syms, etc. It is guaranteed that the non_syms list has one more element than the syms list.

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

getAppsTyHead_maybe :: [LHsAppType pass] -> Maybe (LHsType pass, [LHsType pass], LexicalFixity) Source #

Retrieves the head of an HsAppsTy, if this can be done unambiguously, without consulting fixities.

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

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

mkHsAppTy :: LHsType pass -> LHsType pass -> LHsType pass Source #

mkHsAppTys :: LHsType pass -> [LHsType pass] -> LHsType pass Source #

ignoreParens :: LHsType pass -> LHsType pass Source #

hsSigType :: LHsSigType pass -> LHsType pass Source #

hsSigWcType :: LHsSigWcType pass -> LHsType pass Source #

hsLTyVarBndrToType :: LHsTyVarBndr pass -> LHsType pass Source #

Convert a LHsTyVarBndr to an equivalent LHsType.

hsLTyVarBndrsToTypes :: LHsQTyVars pass -> [LHsType pass] Source #

Convert a LHsTyVarBndrs to a list of types. Works on *type* variable only, no kind vars.

pprHsType :: (SourceTextX pass, OutputableBndrId pass) => HsType pass -> SDoc Source #

pprHsForAll :: (SourceTextX pass, OutputableBndrId pass) => [LHsTyVarBndr pass] -> LHsContext pass -> SDoc Source #

pprHsForAllTvs :: (SourceTextX pass, OutputableBndrId pass) => [LHsTyVarBndr pass] -> SDoc Source #

pprHsForAllExtra :: (SourceTextX pass, OutputableBndrId pass) => Maybe SrcSpan -> [LHsTyVarBndr pass] -> LHsContext pass -> 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 :: (SourceTextX pass, OutputableBndrId pass) => HsContext pass -> SDoc Source #

pprHsContextNoArrow :: (SourceTextX pass, OutputableBndrId pass) => HsContext pass -> SDoc Source #

pprHsContextMaybe :: (SourceTextX pass, OutputableBndrId pass) => HsContext pass -> Maybe SDoc Source #

isCompoundHsType :: LHsType pass -> Bool Source #

Return True for compound types that will need parentheses when used in an argument position.

parenthesizeCompoundHsType :: LHsType pass -> LHsType pass Source #

parenthesizeCompoundHsType ty checks if isCompoundHsType ty is true, and if so, surrounds ty with an HsParTy. Otherwise, it simply returns ty.