ghc-lib-parser-9.14.1.20251220: The GHC API, decoupled from GHC versions

Safe Haskell | Ignore
Language | GHC2021

Language.Haskell.Syntax.Type

Synopsis

- type HsMultAnn pass = HsMultAnnOf (LHsType (NoGhcTc pass)) pass
- data HsMultAnnOf mult pass
  - = HsUnannotated !(XUnannotated mult pass)
  - | HsLinearAnn !(XLinearAnn mult pass)
  - | HsExplicitMult !(XExplicitMult mult pass) !mult
  - | XMultAnnOf !(XXMultAnnOf mult pass)
- type family XUnannotated mult p
- type family XLinearAnn mult p
- type family XExplicitMult mult p
- type family XXMultAnnOf mult p
- data HsType pass
  - = HsForAllTy {
    - hst_xforall :: XForAllTy pass
    - hst_tele :: HsForAllTelescope pass
    - hst_body :: LHsType pass
    }
  - | HsQualTy {
    - hst_xqual :: XQualTy pass
    - hst_ctxt :: LHsContext pass
    - hst_body :: LHsType pass
    }
  - | HsTyVar (XTyVar pass) PromotionFlag (LIdOccP pass)
  - | HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)
  - | HsAppKindTy (XAppKindTy pass) (LHsType pass) (LHsKind pass)
  - | HsFunTy (XFunTy pass) (HsMultAnn pass) (LHsType pass) (LHsType pass)
  - | HsListTy (XListTy pass) (LHsType pass)
  - | HsTupleTy (XTupleTy pass) HsTupleSort [LHsType pass]
  - | HsSumTy (XSumTy pass) [LHsType pass]
  - | HsOpTy (XOpTy pass) PromotionFlag (LHsType pass) (LIdOccP pass) (LHsType pass)
  - | HsParTy (XParTy pass) (LHsType pass)
  - | HsIParamTy (XIParamTy pass) (XRec pass HsIPName) (LHsType pass)
  - | HsStarTy (XStarTy pass) Bool
  - | HsKindSig (XKindSig pass) (LHsType pass) (LHsKind pass)
  - | HsSpliceTy (XSpliceTy pass) (HsUntypedSplice pass)
  - | HsDocTy (XDocTy pass) (LHsType pass) (LHsDoc pass)
  - | HsExplicitListTy (XExplicitListTy pass) PromotionFlag [LHsType pass]
  - | HsExplicitTupleTy (XExplicitTupleTy pass) PromotionFlag [LHsType pass]
  - | HsTyLit (XTyLit pass) (HsTyLit pass)
  - | HsWildCardTy (XWildCardTy pass)
  - | XHsType !(XXType pass)
- type LHsType pass = XRec pass (HsType pass)
- type HsKind pass = HsType pass
- type LHsKind pass = XRec pass (HsKind pass)
- data HsBndrVis pass
  - = HsBndrRequired !(XBndrRequired pass)
  - | HsBndrInvisible !(XBndrInvisible pass)
  - | XBndrVis !(XXBndrVis pass)
- type family XBndrRequired p
- type family XBndrInvisible p
- type family XXBndrVis p
- data HsBndrVar pass
  - = HsBndrVar !(XBndrVar pass) !(LIdP pass)
  - | HsBndrWildCard !(XBndrWildCard pass)
  - | XBndrVar !(XXBndrVar pass)
- type family XBndrVar p
- type family XBndrWildCard p
- type family XXBndrVar p
- data HsBndrKind pass
  - = HsBndrKind !(XBndrKind pass) (LHsKind pass)
  - | HsBndrNoKind !(XBndrNoKind pass)
  - | XBndrKind !(XXBndrKind pass)
- type family XBndrKind p
- type family XBndrNoKind p
- type family XXBndrKind p
- isHsBndrInvisible :: HsBndrVis pass -> Bool
- isHsBndrWildCard :: HsBndrVar pass -> Bool
- data HsForAllTelescope pass
  - = HsForAllVis {
    - hsf_xvis :: XHsForAllVis pass
    - hsf_vis_bndrs :: [LHsTyVarBndr () pass]
    }
  - | HsForAllInvis {
    - hsf_xinvis :: XHsForAllInvis pass
    - hsf_invis_bndrs :: [LHsTyVarBndr Specificity pass]
    }
  - | XHsForAllTelescope !(XXHsForAllTelescope pass)
- data HsTyVarBndr flag pass
  - = HsTvb {
    - tvb_ext :: XTyVarBndr pass
    - tvb_flag :: flag
    - tvb_var :: HsBndrVar pass
    - tvb_kind :: HsBndrKind pass
    }
  - | XTyVarBndr !(XXTyVarBndr pass)
- type LHsTyVarBndr flag pass = XRec pass (HsTyVarBndr flag pass)
- data LHsQTyVars pass
  - = HsQTvs {
    - hsq_ext :: XHsQTvs pass
    - hsq_explicit :: [LHsTyVarBndr (HsBndrVis pass) pass]
    }
  - | XLHsQTyVars !(XXLHsQTyVars pass)
- data HsOuterTyVarBndrs flag pass
  - = HsOuterImplicit {
    - hso_ximplicit :: XHsOuterImplicit pass
    }
  - | HsOuterExplicit {
    - hso_xexplicit :: XHsOuterExplicit pass flag
    - hso_bndrs :: [LHsTyVarBndr flag (NoGhcTc pass)]
    }
  - | XHsOuterTyVarBndrs !(XXHsOuterTyVarBndrs pass)
- type HsOuterFamEqnTyVarBndrs = HsOuterTyVarBndrs ()
- type HsOuterSigTyVarBndrs = HsOuterTyVarBndrs Specificity
- data HsWildCardBndrs pass thing
  - = HsWC {
    - hswc_ext :: XHsWC pass thing
    - hswc_body :: thing
    }
  - | XHsWildCardBndrs !(XXHsWildCardBndrs pass thing)
- data HsPatSigType pass
  - = HsPS {
    - hsps_ext :: XHsPS pass
    - hsps_body :: LHsType pass
    }
  - | XHsPatSigType !(XXHsPatSigType pass)
- data HsSigType pass
  - = HsSig {
    - sig_ext :: XHsSig pass
    - sig_bndrs :: HsOuterSigTyVarBndrs pass
    - sig_body :: LHsType pass
    }
  - | XHsSigType !(XXHsSigType pass)
- type LHsSigType pass = XRec pass (HsSigType pass)
- type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass)
- type LHsWcType pass = HsWildCardBndrs pass (LHsType pass)
- data HsTyPat pass
  - = HsTP {
    - hstp_ext :: XHsTP pass
    - hstp_body :: LHsType pass
    }
  - | XHsTyPat !(XXHsTyPat pass)
- type LHsTyPat pass = XRec pass (HsTyPat pass)
- data HsTupleSort
  - = HsUnboxedTuple
  - | HsBoxedOrConstraintTuple
- type HsContext pass = [LHsType pass]
- type LHsContext pass = XRec pass (HsContext pass)
- data HsTyLit pass
  - = HsNumTy (XNumTy pass) Integer
  - | HsStrTy (XStrTy pass) FastString
  - | HsCharTy (XCharTy pass) Char
  - | XTyLit !(XXTyLit pass)
- newtype HsIPName = HsIPName FastString
- hsIPNameFS :: HsIPName -> FastString
- data HsArg p tm ty
  - = HsValArg !(XValArg p) tm
  - | HsTypeArg !(XTypeArg p) ty
  - | HsArgPar !(XArgPar p)
  - | XArg !(XXArg p)
- type family XValArg p
- type family XTypeArg p
- type family XArgPar p
- type family XXArg p
- type LHsTypeArg p = HsArg p (LHsType p) (LHsKind p)
- data PromotionFlag
  - = NotPromoted
  - | IsPromoted
- isPromoted :: PromotionFlag -> Bool
- data HsConDeclRecField pass
  - = HsConDeclRecField {
    - cdrf_ext :: XConDeclRecField pass
    - cdrf_names :: [LFieldOcc pass]
    - cdrf_spec :: HsConDeclField pass
    }
  - | XConDeclRecField !(XXConDeclRecField pass)
- type LHsConDeclRecField pass = XRec pass (HsConDeclRecField pass)
- data HsConDetails arg rec
  - = PrefixCon [arg]
  - | RecCon rec
  - | InfixCon arg arg
- data HsConDeclField pass = CDF {
  - cdf_ext :: XConDeclField pass
  - cdf_unpack :: SrcUnpackedness
  - cdf_bang :: SrcStrictness
  - cdf_multiplicity :: HsMultAnn pass
  - cdf_type :: LHsType pass
  - cdf_doc :: Maybe (LHsDoc pass)
  }
- data FieldOcc pass
  - = FieldOcc {
    - foExt :: XCFieldOcc pass
    - foLabel :: LIdP pass
    }
  - | XFieldOcc !(XXFieldOcc pass)
- type LFieldOcc pass = XRec pass (FieldOcc pass)
- mapHsOuterImplicit :: (XHsOuterImplicit pass -> XHsOuterImplicit pass) -> HsOuterTyVarBndrs flag pass -> HsOuterTyVarBndrs flag pass
- hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr (HsBndrVis pass) pass]
- isHsKindedTyVar :: HsTyVarBndr flag pass -> Bool

# Documentation

type HsMultAnn pass = HsMultAnnOf (LHsType (NoGhcTc pass)) pass #

data HsMultAnnOf mult pass #

Denotes multiplicity annotations in the surface language. The `mult` type argument is usually `LHsType (NoGhcTc pass)`, but when the annotation is part of a type used in a term, it is `LHsExpr pass`. See Note [Types in terms].

Constructors

HsUnannotated !(XUnannotated mult pass) | a -> b or a → b or { nm :: a }
HsLinearAnn !(XLinearAnn mult pass) | a %1 -> b or a %1 → b, or a ⊸ b, or { nm %1 :: a }
HsExplicitMult !(XExplicitMult mult pass) !mult | a %m -> b or a %m → b or { nm %m :: a } (very much including `a %Many -> b`! This is how the programmer wrote it). It is stored as an `HsType` so as to preserve the syntax as written in the program.
XMultAnnOf !(XXMultAnnOf mult pass) |

#### Instances

Instances details

Data (HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs -> c (HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs) #

toConstr :: HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs -> Constr #

dataTypeOf :: HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs)) #

gmapT :: (forall b. Data b => b -> b) -> HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs -> HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs -> m (HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs -> m (HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs -> m (HsMultAnnOf (LocatedA (HsExpr GhcPs)) GhcPs) #

Data (HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> c (HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn) #

toConstr :: HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> Constr #

dataTypeOf :: HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn)) #

gmapT :: (forall b. Data b => b -> b) -> HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> m (HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> m (HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> m (HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn) #

Data (HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc -> c (HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc) #

toConstr :: HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc -> Constr #

dataTypeOf :: HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc)) #

gmapT :: (forall b. Data b => b -> b) -> HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc -> HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc -> m (HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc -> m (HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc -> m (HsMultAnnOf (LocatedA (HsExpr GhcTc)) GhcTc) #

Data (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> c (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) #

toConstr :: HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> Constr #

dataTypeOf :: HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs)) #

gmapT :: (forall b. Data b => b -> b) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> m (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> m (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> m (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) #

Data (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) #

toConstr :: HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> Constr #

dataTypeOf :: HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn)) #

gmapT :: (forall b. Data b => b -> b) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) #

Data (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) #

toConstr :: HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> Constr #

dataTypeOf :: HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc)) #

gmapT :: (forall b. Data b => b -> b) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) #

(Outputable mult, OutputableBndrId pass) => Outputable (HsMultAnnOf mult (GhcPass pass)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsMultAnnOf mult (GhcPass pass) -> SDoc #

type family XUnannotated mult p #

#### Instances

Instances details

type XUnannotated _1 GhcPs # |
Instance details Defined in GHC.Hs.Type type XUnannotated _1 GhcPs = EpArrowOrColon
type XUnannotated _1 GhcRn # |
Instance details Defined in GHC.Hs.Type type XUnannotated _1 GhcRn = NoExtField
type XUnannotated _1 GhcTc # |
Instance details Defined in GHC.Hs.Type type XUnannotated _1 GhcTc = Mult

type family XLinearAnn mult p #

#### Instances

Instances details

type XLinearAnn _1 GhcPs # |
Instance details Defined in GHC.Hs.Type type XLinearAnn _1 GhcPs = EpLinear
type XLinearAnn _1 GhcRn # |
Instance details Defined in GHC.Hs.Type type XLinearAnn _1 GhcRn = NoExtField
type XLinearAnn _1 GhcTc # |
Instance details Defined in GHC.Hs.Type type XLinearAnn _1 GhcTc = Mult

type family XExplicitMult mult p #

#### Instances

Instances details

type XExplicitMult _1 GhcPs # |
Instance details Defined in GHC.Hs.Type type XExplicitMult _1 GhcPs = (EpToken "%", EpArrowOrColon)
type XExplicitMult _1 GhcRn # |
Instance details Defined in GHC.Hs.Type type XExplicitMult _1 GhcRn = NoExtField
type XExplicitMult _1 GhcTc # |
Instance details Defined in GHC.Hs.Type type XExplicitMult _1 GhcTc = Mult

type family XXMultAnnOf mult p #

#### Instances

Instances details

type XXMultAnnOf _1 (GhcPass _2) # |
Instance details Defined in GHC.Hs.Type type XXMultAnnOf _1 (GhcPass _2) = DataConCantHappen

data HsType pass #

Haskell Type

Constructors

HsForAllTy |

Fields

- hst_xforall :: XForAllTy pass
- hst_tele :: HsForAllTelescope pass
- hst_body :: LHsType pass

HsQualTy |

Fields

- hst_xqual :: XQualTy pass
- hst_ctxt :: LHsContext pass
- hst_body :: LHsType pass

HsTyVar (XTyVar pass) PromotionFlag (LIdOccP pass) |
HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass) |
HsAppKindTy (XAppKindTy pass) (LHsType pass) (LHsKind pass) |
HsFunTy (XFunTy pass) (HsMultAnn pass) (LHsType pass) (LHsType pass) |
HsListTy (XListTy pass) (LHsType pass) |
HsTupleTy (XTupleTy pass) HsTupleSort [LHsType pass] |
HsSumTy (XSumTy pass) [LHsType pass] |
HsOpTy (XOpTy pass) PromotionFlag (LHsType pass) (LIdOccP pass) (LHsType pass) |
HsParTy (XParTy pass) (LHsType pass) |

HsIParamTy (XIParamTy pass) (XRec pass HsIPName) (LHsType pass)

    (?x :: ty)

HsStarTy (XStarTy pass) Bool |

HsKindSig (XKindSig pass) (LHsType pass) (LHsKind pass)

    (ty :: kind)

HsSpliceTy (XSpliceTy pass) (HsUntypedSplice pass) |
HsDocTy (XDocTy pass) (LHsType pass) (LHsDoc pass) |
HsExplicitListTy (XExplicitListTy pass) PromotionFlag [LHsType pass] |
HsExplicitTupleTy (XExplicitTupleTy pass) PromotionFlag [LHsType pass] |
HsTyLit (XTyLit pass) (HsTyLit pass) |
HsWildCardTy (XWildCardTy pass) |
XHsType !(XXType pass) |

#### Instances

Instances details

Data (HsType GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType GhcPs -> c (HsType GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsType GhcPs) #

toConstr :: HsType GhcPs -> Constr #

dataTypeOf :: HsType GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsType GhcPs -> HsType GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsType GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType GhcPs -> m (HsType GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcPs -> m (HsType GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcPs -> m (HsType GhcPs) #

Data (HsType GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType GhcRn -> c (HsType GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsType GhcRn) #

toConstr :: HsType GhcRn -> Constr #

dataTypeOf :: HsType GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsType GhcRn -> HsType GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsType GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType GhcRn -> m (HsType GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcRn -> m (HsType GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcRn -> m (HsType GhcRn) #

Data (HsType GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsType GhcTc -> c (HsType GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsType GhcTc) #

toConstr :: HsType GhcTc -> Constr #

dataTypeOf :: HsType GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsType GhcTc -> HsType GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsType GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsType GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsType GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsType GhcTc -> m (HsType GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcTc -> m (HsType GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsType GhcTc -> m (HsType GhcTc) #

DisambTD (HsType GhcPs) # |

Instance details

Defined in GHC.Parser.PostProcess

Methods

mkHsAppTyHeadPV :: LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) #

mkHsAppTyPV :: LocatedA (HsType GhcPs) -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) #

mkHsAppKindTyPV :: LocatedA (HsType GhcPs) -> EpToken "@" -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) #

mkHsOpTyPV :: PromotionFlag -> LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) #

mkUnpackednessPV :: Located UnpackednessPragma -> LocatedA (HsType GhcPs) -> PV (LocatedA (HsType GhcPs)) #

OutputableBndrId p => Outputable (HsType (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsType (GhcPass p) -> SDoc #
Data (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> c (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) #

toConstr :: HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> Constr #

dataTypeOf :: HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs)) #

gmapT :: (forall b. Data b => b -> b) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> m (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> m (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs -> m (HsMultAnnOf (LocatedA (HsType GhcPs)) GhcPs) #

Data (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) #

toConstr :: HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> Constr #

dataTypeOf :: HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn)) #

gmapT :: (forall b. Data b => b -> b) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcRn) #

Data (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) #

toConstr :: HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> Constr #

dataTypeOf :: HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc)) #

gmapT :: (forall b. Data b => b -> b) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc -> m (HsMultAnnOf (LocatedA (HsType GhcRn)) GhcTc) #

type Anno (HsKind (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type type Anno (HsKind (GhcPass p)) = SrcSpanAnnA
type Anno (HsType (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type type Anno (HsType (GhcPass p)) = SrcSpanAnnA
type Anno [LocatedA (HsType (GhcPass p))] # |
Instance details Defined in GHC.Hs.Type type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC
type Anno (FamEqn p (LocatedA (HsType p))) # |
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

type LHsType pass = XRec pass (HsType pass) #

Located Haskell Type

type HsKind pass = HsType pass #

Haskell Kind

type LHsKind pass = XRec pass (HsKind pass) #

Located Haskell Kind

data HsBndrVis pass #

Constructors

HsBndrRequired !(XBndrRequired pass) |
HsBndrInvisible !(XBndrInvisible pass) |
XBndrVis !(XXBndrVis pass) |

#### Instances

Instances details

Data (HsBndrVis GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBndrVis GhcPs -> c (HsBndrVis GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsBndrVis GhcPs) #

toConstr :: HsBndrVis GhcPs -> Constr #

dataTypeOf :: HsBndrVis GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsBndrVis GhcPs -> HsBndrVis GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVis GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVis GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsBndrVis GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBndrVis GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBndrVis GhcPs -> m (HsBndrVis GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVis GhcPs -> m (HsBndrVis GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVis GhcPs -> m (HsBndrVis GhcPs) #

Data (HsBndrVis GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBndrVis GhcRn -> c (HsBndrVis GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsBndrVis GhcRn) #

toConstr :: HsBndrVis GhcRn -> Constr #

dataTypeOf :: HsBndrVis GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsBndrVis GhcRn -> HsBndrVis GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVis GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVis GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsBndrVis GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBndrVis GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBndrVis GhcRn -> m (HsBndrVis GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVis GhcRn -> m (HsBndrVis GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVis GhcRn -> m (HsBndrVis GhcRn) #

Data (HsBndrVis GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBndrVis GhcTc -> c (HsBndrVis GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsBndrVis GhcTc) #

toConstr :: HsBndrVis GhcTc -> Constr #

dataTypeOf :: HsBndrVis GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsBndrVis GhcTc -> HsBndrVis GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVis GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVis GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsBndrVis GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBndrVis GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBndrVis GhcTc -> m (HsBndrVis GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVis GhcTc -> m (HsBndrVis GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVis GhcTc -> m (HsBndrVis GhcTc) #

OutputableBndrFlag (HsBndrVis (GhcPass p')) p # |
Instance details Defined in GHC.Hs.Type Methods pprTyVarBndr :: HsTyVarBndr (HsBndrVis (GhcPass p')) (GhcPass p) -> SDoc

type family XBndrRequired p #

#### Instances

Instances details

type XBndrRequired (GhcPass _1) # |
Instance details Defined in GHC.Hs.Type type XBndrRequired (GhcPass _1) = NoExtField

type family XBndrInvisible p #

#### Instances

Instances details

type XBndrInvisible GhcPs # |
Instance details Defined in GHC.Hs.Type type XBndrInvisible GhcPs = EpToken "@"
type XBndrInvisible GhcRn # |
Instance details Defined in GHC.Hs.Type type XBndrInvisible GhcRn = NoExtField
type XBndrInvisible GhcTc # |
Instance details Defined in GHC.Hs.Type type XBndrInvisible GhcTc = NoExtField

type family XXBndrVis p #

#### Instances

Instances details

type XXBndrVis (GhcPass _1) # |
Instance details Defined in GHC.Hs.Type type XXBndrVis (GhcPass _1) = DataConCantHappen

data HsBndrVar pass #

Constructors

HsBndrVar !(XBndrVar pass) !(LIdP pass) |
HsBndrWildCard !(XBndrWildCard pass) |
XBndrVar !(XXBndrVar pass) |

#### Instances

Instances details

Data (HsBndrVar GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBndrVar GhcPs -> c (HsBndrVar GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsBndrVar GhcPs) #

toConstr :: HsBndrVar GhcPs -> Constr #

dataTypeOf :: HsBndrVar GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsBndrVar GhcPs -> HsBndrVar GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVar GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVar GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsBndrVar GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBndrVar GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBndrVar GhcPs -> m (HsBndrVar GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVar GhcPs -> m (HsBndrVar GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVar GhcPs -> m (HsBndrVar GhcPs) #

Data (HsBndrVar GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBndrVar GhcRn -> c (HsBndrVar GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsBndrVar GhcRn) #

toConstr :: HsBndrVar GhcRn -> Constr #

dataTypeOf :: HsBndrVar GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsBndrVar GhcRn -> HsBndrVar GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVar GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVar GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsBndrVar GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBndrVar GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBndrVar GhcRn -> m (HsBndrVar GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVar GhcRn -> m (HsBndrVar GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVar GhcRn -> m (HsBndrVar GhcRn) #

Data (HsBndrVar GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBndrVar GhcTc -> c (HsBndrVar GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsBndrVar GhcTc) #

toConstr :: HsBndrVar GhcTc -> Constr #

dataTypeOf :: HsBndrVar GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsBndrVar GhcTc -> HsBndrVar GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVar GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrVar GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsBndrVar GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBndrVar GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBndrVar GhcTc -> m (HsBndrVar GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVar GhcTc -> m (HsBndrVar GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrVar GhcTc -> m (HsBndrVar GhcTc) #

OutputableBndrId p => Outputable (HsBndrVar (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsBndrVar (GhcPass p) -> SDoc #

type family XBndrVar p #

#### Instances

Instances details

type XBndrVar (GhcPass p) # |
Instance details Defined in GHC.Hs.Type type XBndrVar (GhcPass p) = NoExtField

type family XBndrWildCard p #

#### Instances

Instances details

type XBndrWildCard GhcPs # |
Instance details Defined in GHC.Hs.Type type XBndrWildCard GhcPs = EpToken "_"
type XBndrWildCard GhcRn # |
Instance details Defined in GHC.Hs.Type type XBndrWildCard GhcRn = NoExtField
type XBndrWildCard GhcTc # |
Instance details Defined in GHC.Hs.Type type XBndrWildCard GhcTc = NoExtField

type family XXBndrVar p #

#### Instances

Instances details

type XXBndrVar (GhcPass p) # |
Instance details Defined in GHC.Hs.Type type XXBndrVar (GhcPass p) = DataConCantHappen

data HsBndrKind pass #

Constructors

HsBndrKind !(XBndrKind pass) (LHsKind pass) |
HsBndrNoKind !(XBndrNoKind pass) |
XBndrKind !(XXBndrKind pass) |

#### Instances

Instances details

Data (HsBndrKind GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBndrKind GhcPs -> c (HsBndrKind GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsBndrKind GhcPs) #

toConstr :: HsBndrKind GhcPs -> Constr #

dataTypeOf :: HsBndrKind GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsBndrKind GhcPs -> HsBndrKind GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrKind GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrKind GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsBndrKind GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBndrKind GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBndrKind GhcPs -> m (HsBndrKind GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrKind GhcPs -> m (HsBndrKind GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrKind GhcPs -> m (HsBndrKind GhcPs) #

Data (HsBndrKind GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBndrKind GhcRn -> c (HsBndrKind GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsBndrKind GhcRn) #

toConstr :: HsBndrKind GhcRn -> Constr #

dataTypeOf :: HsBndrKind GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsBndrKind GhcRn -> HsBndrKind GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrKind GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrKind GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsBndrKind GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBndrKind GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBndrKind GhcRn -> m (HsBndrKind GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrKind GhcRn -> m (HsBndrKind GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrKind GhcRn -> m (HsBndrKind GhcRn) #

Data (HsBndrKind GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBndrKind GhcTc -> c (HsBndrKind GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsBndrKind GhcTc) #

toConstr :: HsBndrKind GhcTc -> Constr #

dataTypeOf :: HsBndrKind GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsBndrKind GhcTc -> HsBndrKind GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrKind GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBndrKind GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsBndrKind GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBndrKind GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBndrKind GhcTc -> m (HsBndrKind GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrKind GhcTc -> m (HsBndrKind GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBndrKind GhcTc -> m (HsBndrKind GhcTc) #

type family XBndrKind p #

#### Instances

Instances details

type XBndrKind (GhcPass p) # |
Instance details Defined in GHC.Hs.Type type XBndrKind (GhcPass p) = NoExtField

type family XBndrNoKind p #

#### Instances

Instances details

type XBndrNoKind (GhcPass p) # |
Instance details Defined in GHC.Hs.Type type XBndrNoKind (GhcPass p) = NoExtField

type family XXBndrKind p #

#### Instances

Instances details

type XXBndrKind (GhcPass p) # |
Instance details Defined in GHC.Hs.Type type XXBndrKind (GhcPass p) = DataConCantHappen

isHsBndrInvisible :: HsBndrVis pass -> Bool #

isHsBndrWildCard :: HsBndrVar pass -> Bool #

data HsForAllTelescope pass #

The type variable binders in an `HsForAllTy`. See also `Note [Variable Specificity and Forall Visibility]` in GHC.Tc.Gen.HsType.

Constructors

HsForAllVis | A visible `forall` (e.g., `forall a -> {...}`). These do not have any notion of specificity, so we use `()` as a placeholder value.

Fields

- hsf_xvis :: XHsForAllVis pass
- hsf_vis_bndrs :: [LHsTyVarBndr () pass]

HsForAllInvis | An invisible `forall` (e.g., `forall a {b} c. {...}`), where each binder has a `Specificity`.

Fields

- hsf_xinvis :: XHsForAllInvis pass
- hsf_invis_bndrs :: [LHsTyVarBndr Specificity pass]

XHsForAllTelescope !(XXHsForAllTelescope pass) |

#### Instances

Instances details

Data (HsForAllTelescope GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsForAllTelescope GhcPs -> c (HsForAllTelescope GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsForAllTelescope GhcPs) #

toConstr :: HsForAllTelescope GhcPs -> Constr #

dataTypeOf :: HsForAllTelescope GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsForAllTelescope GhcPs -> HsForAllTelescope GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsForAllTelescope GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsForAllTelescope GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsForAllTelescope GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsForAllTelescope GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsForAllTelescope GhcPs -> m (HsForAllTelescope GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsForAllTelescope GhcPs -> m (HsForAllTelescope GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsForAllTelescope GhcPs -> m (HsForAllTelescope GhcPs) #

Data (HsForAllTelescope GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsForAllTelescope GhcRn -> c (HsForAllTelescope GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsForAllTelescope GhcRn) #

toConstr :: HsForAllTelescope GhcRn -> Constr #

dataTypeOf :: HsForAllTelescope GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsForAllTelescope GhcRn -> HsForAllTelescope GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsForAllTelescope GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsForAllTelescope GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsForAllTelescope GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsForAllTelescope GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsForAllTelescope GhcRn -> m (HsForAllTelescope GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsForAllTelescope GhcRn -> m (HsForAllTelescope GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsForAllTelescope GhcRn -> m (HsForAllTelescope GhcRn) #

Data (HsForAllTelescope GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsForAllTelescope GhcTc -> c (HsForAllTelescope GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsForAllTelescope GhcTc) #

toConstr :: HsForAllTelescope GhcTc -> Constr #

dataTypeOf :: HsForAllTelescope GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsForAllTelescope GhcTc -> HsForAllTelescope GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsForAllTelescope GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsForAllTelescope GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsForAllTelescope GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsForAllTelescope GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsForAllTelescope GhcTc -> m (HsForAllTelescope GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsForAllTelescope GhcTc -> m (HsForAllTelescope GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsForAllTelescope GhcTc -> m (HsForAllTelescope GhcTc) #

OutputableBndrId p => Outputable (HsForAllTelescope (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsForAllTelescope (GhcPass p) -> SDoc #

data HsTyVarBndr flag pass #

Haskell Type Variable Binder See Note [Type variable binders]

Constructors

HsTvb |

Fields

- tvb_ext :: XTyVarBndr pass
- tvb_flag :: flag
- tvb_var :: HsBndrVar pass
- tvb_kind :: HsBndrKind pass

XTyVarBndr !(XXTyVarBndr pass) |

#### Instances

Instances details

Data flag => Data (HsTyVarBndr flag GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyVarBndr flag GhcPs -> c (HsTyVarBndr flag GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyVarBndr flag GhcPs) #

toConstr :: HsTyVarBndr flag GhcPs -> Constr #

dataTypeOf :: HsTyVarBndr flag GhcPs -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsTyVarBndr flag GhcPs)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsTyVarBndr flag GhcPs)) #

gmapT :: (forall b. Data b => b -> b) -> HsTyVarBndr flag GhcPs -> HsTyVarBndr flag GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr flag GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr flag GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsTyVarBndr flag GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyVarBndr flag GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyVarBndr flag GhcPs -> m (HsTyVarBndr flag GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr flag GhcPs -> m (HsTyVarBndr flag GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr flag GhcPs -> m (HsTyVarBndr flag GhcPs) #

Data flag => Data (HsTyVarBndr flag GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyVarBndr flag GhcRn -> c (HsTyVarBndr flag GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyVarBndr flag GhcRn) #

toConstr :: HsTyVarBndr flag GhcRn -> Constr #

dataTypeOf :: HsTyVarBndr flag GhcRn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsTyVarBndr flag GhcRn)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsTyVarBndr flag GhcRn)) #

gmapT :: (forall b. Data b => b -> b) -> HsTyVarBndr flag GhcRn -> HsTyVarBndr flag GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr flag GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr flag GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsTyVarBndr flag GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyVarBndr flag GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyVarBndr flag GhcRn -> m (HsTyVarBndr flag GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr flag GhcRn -> m (HsTyVarBndr flag GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr flag GhcRn -> m (HsTyVarBndr flag GhcRn) #

Data flag => Data (HsTyVarBndr flag GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyVarBndr flag GhcTc -> c (HsTyVarBndr flag GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyVarBndr flag GhcTc) #

toConstr :: HsTyVarBndr flag GhcTc -> Constr #

dataTypeOf :: HsTyVarBndr flag GhcTc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsTyVarBndr flag GhcTc)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsTyVarBndr flag GhcTc)) #

gmapT :: (forall b. Data b => b -> b) -> HsTyVarBndr flag GhcTc -> HsTyVarBndr flag GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr flag GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyVarBndr flag GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsTyVarBndr flag GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyVarBndr flag GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyVarBndr flag GhcTc -> m (HsTyVarBndr flag GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr flag GhcTc -> m (HsTyVarBndr flag GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyVarBndr flag GhcTc -> m (HsTyVarBndr flag GhcTc) #

(OutputableBndrId p, OutputableBndrFlag flag p) => Outputable (HsTyVarBndr flag (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsTyVarBndr flag (GhcPass p) -> SDoc #
type Anno (HsTyVarBndr _flag (GhcPass _1)) # |
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag (GhcPass _1)) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcPs) # |
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcPs) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcRn) # |
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcRn) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcTc) # |
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcTc) = SrcSpanAnnA

type LHsTyVarBndr flag pass = XRec pass (HsTyVarBndr flag pass) #

Located Haskell Type Variable Binder

data LHsQTyVars pass #

Located Haskell Quantified Type Variables

Constructors

HsQTvs |

Fields

- hsq_ext :: XHsQTvs pass
- hsq_explicit :: [LHsTyVarBndr (HsBndrVis pass) pass]

XLHsQTyVars !(XXLHsQTyVars pass) |

#### Instances

Instances details

Data (LHsQTyVars GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsQTyVars GhcPs -> c (LHsQTyVars GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsQTyVars GhcPs) #

toConstr :: LHsQTyVars GhcPs -> Constr #

dataTypeOf :: LHsQTyVars GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> LHsQTyVars GhcPs -> LHsQTyVars GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> LHsQTyVars GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsQTyVars GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcPs -> m (LHsQTyVars GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcPs -> m (LHsQTyVars GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcPs -> m (LHsQTyVars GhcPs) #

Data (LHsQTyVars GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsQTyVars GhcRn -> c (LHsQTyVars GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsQTyVars GhcRn) #

toConstr :: LHsQTyVars GhcRn -> Constr #

dataTypeOf :: LHsQTyVars GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> LHsQTyVars GhcRn -> LHsQTyVars GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> LHsQTyVars GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsQTyVars GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcRn -> m (LHsQTyVars GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcRn -> m (LHsQTyVars GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcRn -> m (LHsQTyVars GhcRn) #

Data (LHsQTyVars GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LHsQTyVars GhcTc -> c (LHsQTyVars GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LHsQTyVars GhcTc) #

toConstr :: LHsQTyVars GhcTc -> Constr #

dataTypeOf :: LHsQTyVars GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> LHsQTyVars GhcTc -> LHsQTyVars GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LHsQTyVars GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> LHsQTyVars GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LHsQTyVars GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcTc -> m (LHsQTyVars GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcTc -> m (LHsQTyVars GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LHsQTyVars GhcTc -> m (LHsQTyVars GhcTc) #

OutputableBndrId p => Outputable (LHsQTyVars (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: LHsQTyVars (GhcPass p) -> SDoc #

data HsOuterTyVarBndrs flag pass #

The outermost type variables in a type that obeys the `forall`-or-nothing rule. See `Note [forall-or-nothing rule]`.

Constructors

HsOuterImplicit | Implicit forall, e.g., `f :: a -> b -> b`

Fields

- hso_ximplicit :: XHsOuterImplicit pass

HsOuterExplicit | Explicit forall, e.g., `f :: forall a b. a -> b -> b`

Fields

- hso_xexplicit :: XHsOuterExplicit pass flag
- hso_bndrs :: [LHsTyVarBndr flag (NoGhcTc pass)]

XHsOuterTyVarBndrs !(XXHsOuterTyVarBndrs pass) |

#### Instances

Instances details

Data flag => Data (HsOuterTyVarBndrs flag GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsOuterTyVarBndrs flag GhcPs -> c (HsOuterTyVarBndrs flag GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsOuterTyVarBndrs flag GhcPs) #

toConstr :: HsOuterTyVarBndrs flag GhcPs -> Constr #

dataTypeOf :: HsOuterTyVarBndrs flag GhcPs -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsOuterTyVarBndrs flag GhcPs)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsOuterTyVarBndrs flag GhcPs)) #

gmapT :: (forall b. Data b => b -> b) -> HsOuterTyVarBndrs flag GhcPs -> HsOuterTyVarBndrs flag GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsOuterTyVarBndrs flag GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsOuterTyVarBndrs flag GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsOuterTyVarBndrs flag GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsOuterTyVarBndrs flag GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsOuterTyVarBndrs flag GhcPs -> m (HsOuterTyVarBndrs flag GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsOuterTyVarBndrs flag GhcPs -> m (HsOuterTyVarBndrs flag GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsOuterTyVarBndrs flag GhcPs -> m (HsOuterTyVarBndrs flag GhcPs) #

Data flag => Data (HsOuterTyVarBndrs flag GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsOuterTyVarBndrs flag GhcRn -> c (HsOuterTyVarBndrs flag GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsOuterTyVarBndrs flag GhcRn) #

toConstr :: HsOuterTyVarBndrs flag GhcRn -> Constr #

dataTypeOf :: HsOuterTyVarBndrs flag GhcRn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsOuterTyVarBndrs flag GhcRn)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsOuterTyVarBndrs flag GhcRn)) #

gmapT :: (forall b. Data b => b -> b) -> HsOuterTyVarBndrs flag GhcRn -> HsOuterTyVarBndrs flag GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsOuterTyVarBndrs flag GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsOuterTyVarBndrs flag GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsOuterTyVarBndrs flag GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsOuterTyVarBndrs flag GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsOuterTyVarBndrs flag GhcRn -> m (HsOuterTyVarBndrs flag GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsOuterTyVarBndrs flag GhcRn -> m (HsOuterTyVarBndrs flag GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsOuterTyVarBndrs flag GhcRn -> m (HsOuterTyVarBndrs flag GhcRn) #

Data flag => Data (HsOuterTyVarBndrs flag GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsOuterTyVarBndrs flag GhcTc -> c (HsOuterTyVarBndrs flag GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsOuterTyVarBndrs flag GhcTc) #

toConstr :: HsOuterTyVarBndrs flag GhcTc -> Constr #

dataTypeOf :: HsOuterTyVarBndrs flag GhcTc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsOuterTyVarBndrs flag GhcTc)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsOuterTyVarBndrs flag GhcTc)) #

gmapT :: (forall b. Data b => b -> b) -> HsOuterTyVarBndrs flag GhcTc -> HsOuterTyVarBndrs flag GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsOuterTyVarBndrs flag GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsOuterTyVarBndrs flag GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsOuterTyVarBndrs flag GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsOuterTyVarBndrs flag GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsOuterTyVarBndrs flag GhcTc -> m (HsOuterTyVarBndrs flag GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsOuterTyVarBndrs flag GhcTc -> m (HsOuterTyVarBndrs flag GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsOuterTyVarBndrs flag GhcTc -> m (HsOuterTyVarBndrs flag GhcTc) #

(OutputableBndrFlag flag p, OutputableBndrFlag flag (NoGhcTcPass p), OutputableBndrId p) => Outputable (HsOuterTyVarBndrs flag (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsOuterTyVarBndrs flag (GhcPass p) -> SDoc #
type Anno (HsOuterTyVarBndrs _1 (GhcPass _2)) # |
Instance details Defined in GHC.Hs.Type type Anno (HsOuterTyVarBndrs _1 (GhcPass _2)) = SrcSpanAnnA

type HsOuterFamEqnTyVarBndrs = HsOuterTyVarBndrs () #

Used for type-family instance equations, e.g.,

    type instance forall a. F [a] = Tree a

The notion of specificity is irrelevant in type family equations, so we use `()` for the `HsOuterTyVarBndrs` `flag`.

type HsOuterSigTyVarBndrs = HsOuterTyVarBndrs Specificity #

Used for signatures, e.g.,

    f :: forall a {b}. blah

We use `Specificity` for the `HsOuterTyVarBndrs` `flag` to allow distinguishing between specified and inferred type variables.

data HsWildCardBndrs pass thing #

Haskell Wildcard Binders

Constructors

HsWC |

Fields

- hswc_ext :: XHsWC pass thing
- hswc_body :: thing

XHsWildCardBndrs !(XXHsWildCardBndrs pass thing) |

#### Instances

Instances details

Data thing => Data (HsWildCardBndrs GhcPs thing) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsWildCardBndrs GhcPs thing -> c (HsWildCardBndrs GhcPs thing) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsWildCardBndrs GhcPs thing) #

toConstr :: HsWildCardBndrs GhcPs thing -> Constr #

dataTypeOf :: HsWildCardBndrs GhcPs thing -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsWildCardBndrs GhcPs thing)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsWildCardBndrs GhcPs thing)) #

gmapT :: (forall b. Data b => b -> b) -> HsWildCardBndrs GhcPs thing -> HsWildCardBndrs GhcPs thing #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcPs thing -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcPs thing -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsWildCardBndrs GhcPs thing -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsWildCardBndrs GhcPs thing -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcPs thing -> m (HsWildCardBndrs GhcPs thing) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcPs thing -> m (HsWildCardBndrs GhcPs thing) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcPs thing -> m (HsWildCardBndrs GhcPs thing) #

Data thing => Data (HsWildCardBndrs GhcRn thing) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsWildCardBndrs GhcRn thing -> c (HsWildCardBndrs GhcRn thing) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsWildCardBndrs GhcRn thing) #

toConstr :: HsWildCardBndrs GhcRn thing -> Constr #

dataTypeOf :: HsWildCardBndrs GhcRn thing -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsWildCardBndrs GhcRn thing)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsWildCardBndrs GhcRn thing)) #

gmapT :: (forall b. Data b => b -> b) -> HsWildCardBndrs GhcRn thing -> HsWildCardBndrs GhcRn thing #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcRn thing -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcRn thing -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsWildCardBndrs GhcRn thing -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsWildCardBndrs GhcRn thing -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcRn thing -> m (HsWildCardBndrs GhcRn thing) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcRn thing -> m (HsWildCardBndrs GhcRn thing) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcRn thing -> m (HsWildCardBndrs GhcRn thing) #

Data thing => Data (HsWildCardBndrs GhcTc thing) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsWildCardBndrs GhcTc thing -> c (HsWildCardBndrs GhcTc thing) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsWildCardBndrs GhcTc thing) #

toConstr :: HsWildCardBndrs GhcTc thing -> Constr #

dataTypeOf :: HsWildCardBndrs GhcTc thing -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsWildCardBndrs GhcTc thing)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsWildCardBndrs GhcTc thing)) #

gmapT :: (forall b. Data b => b -> b) -> HsWildCardBndrs GhcTc thing -> HsWildCardBndrs GhcTc thing #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcTc thing -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsWildCardBndrs GhcTc thing -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsWildCardBndrs GhcTc thing -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsWildCardBndrs GhcTc thing -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcTc thing -> m (HsWildCardBndrs GhcTc thing) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcTc thing -> m (HsWildCardBndrs GhcTc thing) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWildCardBndrs GhcTc thing -> m (HsWildCardBndrs GhcTc thing) #

Outputable thing => Outputable (HsWildCardBndrs (GhcPass p) thing) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsWildCardBndrs (GhcPass p) thing -> SDoc #

data HsPatSigType pass #

Types that can appear in pattern signatures, as well as the signatures for term-level binders in RULES. See `Note [Pattern signature binders and scoping]`.

This is very similar to `HsSigWcType`, but with slightly different semantics: see `Note [HsType binders]`. See also `Note [The wildcard story for types]`.

Constructors

HsPS |

Fields

- hsps_ext :: XHsPS pass

  After renamer: `HsPSRn`

- hsps_body :: LHsType pass

  Main payload (the type itself)

XHsPatSigType !(XXHsPatSigType pass) |

#### Instances

Instances details

Data (HsPatSigType GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsPatSigType GhcPs -> c (HsPatSigType GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsPatSigType GhcPs) #

toConstr :: HsPatSigType GhcPs -> Constr #

dataTypeOf :: HsPatSigType GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsPatSigType GhcPs -> HsPatSigType GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPatSigType GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPatSigType GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsPatSigType GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPatSigType GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsPatSigType GhcPs -> m (HsPatSigType GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatSigType GhcPs -> m (HsPatSigType GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatSigType GhcPs -> m (HsPatSigType GhcPs) #

Data (HsPatSigType GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsPatSigType GhcRn -> c (HsPatSigType GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsPatSigType GhcRn) #

toConstr :: HsPatSigType GhcRn -> Constr #

dataTypeOf :: HsPatSigType GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsPatSigType GhcRn -> HsPatSigType GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPatSigType GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPatSigType GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsPatSigType GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPatSigType GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsPatSigType GhcRn -> m (HsPatSigType GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatSigType GhcRn -> m (HsPatSigType GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatSigType GhcRn -> m (HsPatSigType GhcRn) #

Data (HsPatSigType GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsPatSigType GhcTc -> c (HsPatSigType GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsPatSigType GhcTc) #

toConstr :: HsPatSigType GhcTc -> Constr #

dataTypeOf :: HsPatSigType GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsPatSigType GhcTc -> HsPatSigType GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPatSigType GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPatSigType GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsPatSigType GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPatSigType GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsPatSigType GhcTc -> m (HsPatSigType GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatSigType GhcTc -> m (HsPatSigType GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPatSigType GhcTc -> m (HsPatSigType GhcTc) #

OutputableBndrId p => Outputable (HsPatSigType (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsPatSigType (GhcPass p) -> SDoc #

data HsSigType pass #

A type signature that obeys the `forall`-or-nothing rule. In other words, an `LHsType` that uses an `HsOuterSigTyVarBndrs` to represent its outermost type variable quantification. See `Note [Representing type signatures]`.

Constructors

HsSig |

Fields

- sig_ext :: XHsSig pass
- sig_bndrs :: HsOuterSigTyVarBndrs pass
- sig_body :: LHsType pass

XHsSigType !(XXHsSigType pass) |

#### Instances

Instances details

Data (HsSigType GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSigType GhcPs -> c (HsSigType GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsSigType GhcPs) #

toConstr :: HsSigType GhcPs -> Constr #

dataTypeOf :: HsSigType GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsSigType GhcPs -> HsSigType GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSigType GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSigType GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsSigType GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSigType GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSigType GhcPs -> m (HsSigType GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSigType GhcPs -> m (HsSigType GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSigType GhcPs -> m (HsSigType GhcPs) #

Data (HsSigType GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSigType GhcRn -> c (HsSigType GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsSigType GhcRn) #

toConstr :: HsSigType GhcRn -> Constr #

dataTypeOf :: HsSigType GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsSigType GhcRn -> HsSigType GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSigType GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSigType GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsSigType GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSigType GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSigType GhcRn -> m (HsSigType GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSigType GhcRn -> m (HsSigType GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSigType GhcRn -> m (HsSigType GhcRn) #

Data (HsSigType GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSigType GhcTc -> c (HsSigType GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsSigType GhcTc) #

toConstr :: HsSigType GhcTc -> Constr #

dataTypeOf :: HsSigType GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsSigType GhcTc -> HsSigType GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSigType GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSigType GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsSigType GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSigType GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSigType GhcTc -> m (HsSigType GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSigType GhcTc -> m (HsSigType GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSigType GhcTc -> m (HsSigType GhcTc) #

OutputableBndrId p => Outputable (HsSigType (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsSigType (GhcPass p) -> SDoc #
type Anno (HsSigType (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type type Anno (HsSigType (GhcPass p)) = SrcSpanAnnA

type LHsSigType pass = XRec pass (HsSigType pass) #

Located Haskell Signature Type

type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass) #

Located Haskell Signature Wildcard Type

type LHsWcType pass = HsWildCardBndrs pass (LHsType pass) #

Located Haskell Wildcard Type

data HsTyPat pass #

Constructors

HsTP |

Fields

- hstp_ext :: XHsTP pass

  After renamer: `HsTyPatRn`

- hstp_body :: LHsType pass

  Main payload (the type itself)

XHsTyPat !(XXHsTyPat pass) |

#### Instances

Instances details

Data (HsTyPat GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyPat GhcPs -> c (HsTyPat GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyPat GhcPs) #

toConstr :: HsTyPat GhcPs -> Constr #

dataTypeOf :: HsTyPat GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsTyPat GhcPs -> HsTyPat GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyPat GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyPat GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsTyPat GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyPat GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyPat GhcPs -> m (HsTyPat GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyPat GhcPs -> m (HsTyPat GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyPat GhcPs -> m (HsTyPat GhcPs) #

Data (HsTyPat GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyPat GhcRn -> c (HsTyPat GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyPat GhcRn) #

toConstr :: HsTyPat GhcRn -> Constr #

dataTypeOf :: HsTyPat GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsTyPat GhcRn -> HsTyPat GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyPat GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyPat GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsTyPat GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyPat GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyPat GhcRn -> m (HsTyPat GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyPat GhcRn -> m (HsTyPat GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyPat GhcRn -> m (HsTyPat GhcRn) #

Data (HsTyPat GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyPat GhcTc -> c (HsTyPat GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyPat GhcTc) #

toConstr :: HsTyPat GhcTc -> Constr #

dataTypeOf :: HsTyPat GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsTyPat GhcTc -> HsTyPat GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyPat GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyPat GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsTyPat GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyPat GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyPat GhcTc -> m (HsTyPat GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyPat GhcTc -> m (HsTyPat GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyPat GhcTc -> m (HsTyPat GhcTc) #

OutputableBndrId p => Outputable (HsTyPat (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsTyPat (GhcPass p) -> SDoc #

type LHsTyPat pass = XRec pass (HsTyPat pass) #

data HsTupleSort #

Haskell Tuple Sort

Constructors

HsUnboxedTuple |
HsBoxedOrConstraintTuple |

#### Instances

Instances details

Data HsTupleSort # |

Instance details

Defined in Language.Haskell.Syntax.Type

Methods

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

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

toConstr :: HsTupleSort -> Constr #

dataTypeOf :: HsTupleSort -> DataType #

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

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

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

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

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

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

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

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

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

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

type HsContext pass = [LHsType pass] #

Haskell Context

type LHsContext pass = XRec pass (HsContext pass) #

Located Haskell Context

data HsTyLit pass #

Haskell Type Literal

Constructors

HsNumTy (XNumTy pass) Integer |
HsStrTy (XStrTy pass) FastString |
HsCharTy (XCharTy pass) Char |
XTyLit !(XXTyLit pass) |

#### Instances

Instances details

Data (HsTyLit GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyLit GhcPs -> c (HsTyLit GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyLit GhcPs) #

toConstr :: HsTyLit GhcPs -> Constr #

dataTypeOf :: HsTyLit GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsTyLit GhcPs -> HsTyLit GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsTyLit GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyLit GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyLit GhcPs -> m (HsTyLit GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit GhcPs -> m (HsTyLit GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit GhcPs -> m (HsTyLit GhcPs) #

Data (HsTyLit GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyLit GhcRn -> c (HsTyLit GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyLit GhcRn) #

toConstr :: HsTyLit GhcRn -> Constr #

dataTypeOf :: HsTyLit GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsTyLit GhcRn -> HsTyLit GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsTyLit GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyLit GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyLit GhcRn -> m (HsTyLit GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit GhcRn -> m (HsTyLit GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit GhcRn -> m (HsTyLit GhcRn) #

Data (HsTyLit GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyLit GhcTc -> c (HsTyLit GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTyLit GhcTc) #

toConstr :: HsTyLit GhcTc -> Constr #

dataTypeOf :: HsTyLit GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsTyLit GhcTc -> HsTyLit GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsTyLit GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyLit GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyLit GhcTc -> m (HsTyLit GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit GhcTc -> m (HsTyLit GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit GhcTc -> m (HsTyLit GhcTc) #

OutputableBndrId p => Outputable (HsTyLit (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsTyLit (GhcPass p) -> SDoc #

newtype HsIPName #

These names are used early on to store the names of implicit parameters. They completely disappear after type-checking.

Constructors

HsIPName FastString |

#### Instances

Instances details

Data HsIPName # |

Instance details

Defined in Language.Haskell.Syntax.Type

Methods

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

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

toConstr :: HsIPName -> Constr #

dataTypeOf :: HsIPName -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable HsIPName # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsIPName -> SDoc #
OutputableBndr HsIPName # |
Instance details Defined in GHC.Hs.Type Methods pprBndr :: BindingSite -> HsIPName -> SDoc # pprPrefixOcc :: HsIPName -> SDoc # pprInfixOcc :: HsIPName -> SDoc # bndrIsJoin_maybe :: HsIPName -> JoinPointHood #
Eq HsIPName # |
Instance details Defined in Language.Haskell.Syntax.Type Methods (==) :: HsIPName -> HsIPName -> Bool # (/=) :: HsIPName -> HsIPName -> Bool #
type Anno HsIPName # |
Instance details Defined in GHC.Hs.Type type Anno HsIPName = EpAnnCO

hsIPNameFS :: HsIPName -> FastString #

data HsArg p tm ty #

Arguments in an expression/type after splitting

Constructors

HsValArg !(XValArg p) tm |
HsTypeArg !(XTypeArg p) ty |
HsArgPar !(XArgPar p) |
XArg !(XXArg p) |

#### Instances

Instances details

(Data a, Data b) => Data (HsArg GhcPs a b) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> HsArg GhcPs a b -> c (HsArg GhcPs a b) #

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsArg GhcPs a b) #

toConstr :: HsArg GhcPs a b -> Constr #

dataTypeOf :: HsArg GhcPs a b -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsArg GhcPs a b)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsArg GhcPs a b)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> HsArg GhcPs a b -> HsArg GhcPs a b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsArg GhcPs a b -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsArg GhcPs a b -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsArg GhcPs a b -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsArg GhcPs a b -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsArg GhcPs a b -> m (HsArg GhcPs a b) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsArg GhcPs a b -> m (HsArg GhcPs a b) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsArg GhcPs a b -> m (HsArg GhcPs a b) #

(Data a, Data b) => Data (HsArg GhcRn a b) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> HsArg GhcRn a b -> c (HsArg GhcRn a b) #

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsArg GhcRn a b) #

toConstr :: HsArg GhcRn a b -> Constr #

dataTypeOf :: HsArg GhcRn a b -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsArg GhcRn a b)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsArg GhcRn a b)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> HsArg GhcRn a b -> HsArg GhcRn a b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsArg GhcRn a b -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsArg GhcRn a b -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsArg GhcRn a b -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsArg GhcRn a b -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsArg GhcRn a b -> m (HsArg GhcRn a b) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsArg GhcRn a b -> m (HsArg GhcRn a b) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsArg GhcRn a b -> m (HsArg GhcRn a b) #

(Data a, Data b) => Data (HsArg GhcTc a b) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> HsArg GhcTc a b -> c (HsArg GhcTc a b) #

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsArg GhcTc a b) #

toConstr :: HsArg GhcTc a b -> Constr #

dataTypeOf :: HsArg GhcTc a b -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsArg GhcTc a b)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsArg GhcTc a b)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> HsArg GhcTc a b -> HsArg GhcTc a b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsArg GhcTc a b -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsArg GhcTc a b -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsArg GhcTc a b -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsArg GhcTc a b -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsArg GhcTc a b -> m (HsArg GhcTc a b) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsArg GhcTc a b -> m (HsArg GhcTc a b) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsArg GhcTc a b -> m (HsArg GhcTc a b) #

(Outputable tm, Outputable ty) => Outputable (HsArg (GhcPass p) tm ty) # | This instance is meant for debug-printing purposes. If you wish to pretty-print an application of `HsArg`s, use `pprHsArgsApp` instead.
Instance details Defined in GHC.Hs.Type Methods ppr :: HsArg (GhcPass p) tm ty -> SDoc #

type family XValArg p #

#### Instances

Instances details

type XValArg (GhcPass _1) # |
Instance details Defined in GHC.Hs.Type type XValArg (GhcPass _1) = NoExtField

type family XTypeArg p #

#### Instances

Instances details

type XTypeArg GhcPs # |
Instance details Defined in GHC.Hs.Type type XTypeArg GhcPs = EpToken "@"
type XTypeArg GhcRn # |
Instance details Defined in GHC.Hs.Type type XTypeArg GhcRn = NoExtField
type XTypeArg GhcTc # |
Instance details Defined in GHC.Hs.Type type XTypeArg GhcTc = NoExtField

type family XArgPar p #

#### Instances

Instances details

type XArgPar (GhcPass _1) # |
Instance details Defined in GHC.Hs.Type type XArgPar (GhcPass _1) = SrcSpan

type family XXArg p #

#### Instances

Instances details

type XXArg (GhcPass _1) # |
Instance details Defined in GHC.Hs.Type type XXArg (GhcPass _1) = DataConCantHappen

type LHsTypeArg p = HsArg p (LHsType p) (LHsKind p) #

data PromotionFlag #

Is a TyCon a promoted data constructor or just a normal type constructor?

Constructors

NotPromoted |
IsPromoted |

#### Instances

Instances details

NFData PromotionFlag # |
Instance details Defined in Language.Haskell.Syntax.Type Methods rnf :: PromotionFlag -> () #
Data PromotionFlag # |

Instance details

Defined in Language.Haskell.Syntax.Type

Methods

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

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

toConstr :: PromotionFlag -> Constr #

dataTypeOf :: PromotionFlag -> DataType #

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

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

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

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

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

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

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

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

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

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

Binary PromotionFlag # |
Instance details Defined in GHC.Types.Basic Methods put_ :: WriteBinHandle -> PromotionFlag -> IO () # put :: WriteBinHandle -> PromotionFlag -> IO (Bin PromotionFlag) # get :: ReadBinHandle -> IO PromotionFlag #
Outputable PromotionFlag # |
Instance details Defined in GHC.Types.Basic Methods ppr :: PromotionFlag -> SDoc #
Eq PromotionFlag # |
Instance details Defined in Language.Haskell.Syntax.Type Methods (==) :: PromotionFlag -> PromotionFlag -> Bool # (/=) :: PromotionFlag -> PromotionFlag -> Bool #
Ord PromotionFlag # |

Instance details

Defined in Language.Haskell.Syntax.Type

Methods

compare :: PromotionFlag -> PromotionFlag -> Ordering #

(<) :: PromotionFlag -> PromotionFlag -> Bool #

(<=) :: PromotionFlag -> PromotionFlag -> Bool #

(>) :: PromotionFlag -> PromotionFlag -> Bool #

(>=) :: PromotionFlag -> PromotionFlag -> Bool #

max :: PromotionFlag -> PromotionFlag -> PromotionFlag #

min :: PromotionFlag -> PromotionFlag -> PromotionFlag #

isPromoted :: PromotionFlag -> Bool #

data HsConDeclRecField pass #

Constructor Declaration Record Field

Constructors

HsConDeclRecField |

Fields

- cdrf_ext :: XConDeclRecField pass
- cdrf_names :: [LFieldOcc pass]

  See Note [FieldOcc pass]

- cdrf_spec :: HsConDeclField pass

XConDeclRecField !(XXConDeclRecField pass) |

#### Instances

Instances details

Data (HsConDeclRecField GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclRecField GhcPs -> c (HsConDeclRecField GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclRecField GhcPs) #

toConstr :: HsConDeclRecField GhcPs -> Constr #

dataTypeOf :: HsConDeclRecField GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsConDeclRecField GhcPs -> HsConDeclRecField GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclRecField GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclRecField GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsConDeclRecField GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclRecField GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclRecField GhcPs -> m (HsConDeclRecField GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclRecField GhcPs -> m (HsConDeclRecField GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclRecField GhcPs -> m (HsConDeclRecField GhcPs) #

Data (HsConDeclRecField GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclRecField GhcRn -> c (HsConDeclRecField GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclRecField GhcRn) #

toConstr :: HsConDeclRecField GhcRn -> Constr #

dataTypeOf :: HsConDeclRecField GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsConDeclRecField GhcRn -> HsConDeclRecField GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclRecField GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclRecField GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsConDeclRecField GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclRecField GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclRecField GhcRn -> m (HsConDeclRecField GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclRecField GhcRn -> m (HsConDeclRecField GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclRecField GhcRn -> m (HsConDeclRecField GhcRn) #

Data (HsConDeclRecField GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclRecField GhcTc -> c (HsConDeclRecField GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclRecField GhcTc) #

toConstr :: HsConDeclRecField GhcTc -> Constr #

dataTypeOf :: HsConDeclRecField GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsConDeclRecField GhcTc -> HsConDeclRecField GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclRecField GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclRecField GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsConDeclRecField GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclRecField GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclRecField GhcTc -> m (HsConDeclRecField GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclRecField GhcTc -> m (HsConDeclRecField GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclRecField GhcTc -> m (HsConDeclRecField GhcTc) #

OutputableBndrId p => Outputable (HsConDeclRecField (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsConDeclRecField (GhcPass p) -> SDoc #
type Anno (HsConDeclRecField (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type type Anno (HsConDeclRecField (GhcPass p)) = SrcSpanAnnA
type Anno [LocatedA (HsConDeclRecField (GhcPass _1))] # |
Instance details Defined in GHC.Hs.Decls type Anno [LocatedA (HsConDeclRecField (GhcPass _1))] = SrcSpanAnnL

type LHsConDeclRecField pass = XRec pass (HsConDeclRecField pass) #

Located Constructor Declaration Record Field

data HsConDetails arg rec #

Describes the arguments to a data constructor. This is a common representation for several constructor-related concepts, including:

- The arguments in a Haskell98-style constructor declaration (see `HsConDeclH98Details` in GHC.Hs.Decls).
- The arguments in constructor patterns in `case`/function definitions (see `HsConPatDetails` in GHC.Hs.Pat).
- The left-hand side arguments in a pattern synonym binding (see `HsPatSynDetails` in GHC.Hs.Binds).

One notable exception is the arguments in a GADT constructor, which uses a separate data type entirely (see `HsConDeclGADTDetails` in GHC.Hs.Decls). This is because GADT constructors cannot be declared with infix syntax, unlike the concepts above (#18844).

Constructors

PrefixCon [arg] |
RecCon rec |
InfixCon arg arg |

#### Instances

Instances details

(Data rec, Data arg) => Data (HsConDetails arg rec) # |

Instance details

Defined in Language.Haskell.Syntax.Type

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDetails arg rec -> c (HsConDetails arg rec) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDetails arg rec) #

toConstr :: HsConDetails arg rec -> Constr #

dataTypeOf :: HsConDetails arg rec -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDetails arg rec)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDetails arg rec)) #

gmapT :: (forall b. Data b => b -> b) -> HsConDetails arg rec -> HsConDetails arg rec #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsConDetails arg rec -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDetails arg rec -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) #

(Outputable arg, Outputable rec) => Outputable (HsConDetails arg rec) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: HsConDetails arg rec -> SDoc #

data HsConDeclField pass #

Constructor declaration field specification, see Note [HsConDeclField on pass]

Constructors

CDF |

Fields

- cdf_ext :: XConDeclField pass

  Extension point

- cdf_unpack :: SrcUnpackedness

  UNPACK pragma if any E.g. data T = MkT {-# UNPACK #-} Int or data T where MtT :: {-# UNPACK #-} Int -> T

- cdf_bang :: SrcStrictness

  User-specified strictness, if any E.g. data T a = MkT !a or data T a where MtT :: !a -> T a

- cdf_multiplicity :: HsMultAnn pass

  User-specified multiplicity, if any E.g. data T a = MkT { t %Many :: a } or data T a where MtT :: a %1 -> T a

- cdf_type :: LHsType pass

  The type of the field

- cdf_doc :: Maybe (LHsDoc pass)

  Documentation for the field F.e. this very piece of documentation

#### Instances

Instances details

Data (HsConDeclField GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclField GhcPs -> c (HsConDeclField GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclField GhcPs) #

toConstr :: HsConDeclField GhcPs -> Constr #

dataTypeOf :: HsConDeclField GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsConDeclField GhcPs -> HsConDeclField GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclField GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclField GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsConDeclField GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclField GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclField GhcPs -> m (HsConDeclField GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclField GhcPs -> m (HsConDeclField GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclField GhcPs -> m (HsConDeclField GhcPs) #

Data (HsConDeclField GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclField GhcRn -> c (HsConDeclField GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclField GhcRn) #

toConstr :: HsConDeclField GhcRn -> Constr #

dataTypeOf :: HsConDeclField GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsConDeclField GhcRn -> HsConDeclField GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclField GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclField GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsConDeclField GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclField GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclField GhcRn -> m (HsConDeclField GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclField GhcRn -> m (HsConDeclField GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclField GhcRn -> m (HsConDeclField GhcRn) #

Data (HsConDeclField GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDeclField GhcTc -> c (HsConDeclField GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDeclField GhcTc) #

toConstr :: HsConDeclField GhcTc -> Constr #

dataTypeOf :: HsConDeclField GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsConDeclField GhcTc -> HsConDeclField GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclField GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDeclField GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsConDeclField GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDeclField GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDeclField GhcTc -> m (HsConDeclField GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclField GhcTc -> m (HsConDeclField GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDeclField GhcTc -> m (HsConDeclField GhcTc) #

data FieldOcc pass #

Field Occurrence

Represents an *occurrence* of a field. This may or may not be a binding occurrence (e.g. this type is used in `HsConDeclRecField` and `RecordPatSynField` which bind their fields, but also in `HsRecField` for record construction and patterns, which do not).

We store both the `RdrName` the user originally wrote, and after the renamer we use the extension field to store the selector function. See note [FieldOcc pass]

There is a wrinkle in that update field occurances are sometimes ambiguous during the rename stage. See note [Ambiguous FieldOcc in record updates] to see how we currently handle this.

Constructors

FieldOcc |

Fields

- foExt :: XCFieldOcc pass
- foLabel :: LIdP pass

XFieldOcc !(XXFieldOcc pass) |

#### Instances

Instances details

Data (FieldOcc GhcPs) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldOcc GhcPs -> c (FieldOcc GhcPs) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldOcc GhcPs) #

toConstr :: FieldOcc GhcPs -> Constr #

dataTypeOf :: FieldOcc GhcPs -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> FieldOcc GhcPs -> FieldOcc GhcPs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcPs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcPs -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldOcc GhcPs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldOcc GhcPs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldOcc GhcPs -> m (FieldOcc GhcPs) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcPs -> m (FieldOcc GhcPs) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcPs -> m (FieldOcc GhcPs) #

Data (FieldOcc GhcRn) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldOcc GhcRn -> c (FieldOcc GhcRn) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldOcc GhcRn) #

toConstr :: FieldOcc GhcRn -> Constr #

dataTypeOf :: FieldOcc GhcRn -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> FieldOcc GhcRn -> FieldOcc GhcRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldOcc GhcRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldOcc GhcRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldOcc GhcRn -> m (FieldOcc GhcRn) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcRn -> m (FieldOcc GhcRn) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcRn -> m (FieldOcc GhcRn) #

Data (FieldOcc GhcTc) # |

Instance details

Defined in GHC.Hs.Instances

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldOcc GhcTc -> c (FieldOcc GhcTc) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldOcc GhcTc) #

toConstr :: FieldOcc GhcTc -> Constr #

dataTypeOf :: FieldOcc GhcTc -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> FieldOcc GhcTc -> FieldOcc GhcTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldOcc GhcTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldOcc GhcTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldOcc GhcTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldOcc GhcTc -> m (FieldOcc GhcTc) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcTc -> m (FieldOcc GhcTc) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldOcc GhcTc -> m (FieldOcc GhcTc) #

Outputable (XRecGhc (IdGhcP p)) => Outputable (FieldOcc (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type Methods ppr :: FieldOcc (GhcPass p) -> SDoc #
OutputableBndrId pass => OutputableBndr (FieldOcc (GhcPass pass)) # |
Instance details Defined in GHC.Hs.Type Methods pprBndr :: BindingSite -> FieldOcc (GhcPass pass) -> SDoc # pprPrefixOcc :: FieldOcc (GhcPass pass) -> SDoc # pprInfixOcc :: FieldOcc (GhcPass pass) -> SDoc # bndrIsJoin_maybe :: FieldOcc (GhcPass pass) -> JoinPointHood #
(Eq (LIdP pass), Eq (XCFieldOcc pass), Eq (XXFieldOcc pass)) => Eq (FieldOcc pass) # |
Instance details Defined in Language.Haskell.Syntax.Type Methods (==) :: FieldOcc pass -> FieldOcc pass -> Bool # (/=) :: FieldOcc pass -> FieldOcc pass -> Bool #
OutputableBndrId pass => OutputableBndr (GenLocated SrcSpan (FieldOcc (GhcPass pass))) # |
Instance details Defined in GHC.Hs.Type Methods pprBndr :: BindingSite -> GenLocated SrcSpan (FieldOcc (GhcPass pass)) -> SDoc # pprPrefixOcc :: GenLocated SrcSpan (FieldOcc (GhcPass pass)) -> SDoc # pprInfixOcc :: GenLocated SrcSpan (FieldOcc (GhcPass pass)) -> SDoc # bndrIsJoin_maybe :: GenLocated SrcSpan (FieldOcc (GhcPass pass)) -> JoinPointHood #
type Anno (FieldOcc (GhcPass p)) # |
Instance details Defined in GHC.Hs.Type type Anno (FieldOcc (GhcPass p)) = SrcSpanAnnA

type LFieldOcc pass = XRec pass (FieldOcc pass) #

Located Field Occurrence

mapHsOuterImplicit :: (XHsOuterImplicit pass -> XHsOuterImplicit pass) -> HsOuterTyVarBndrs flag pass -> HsOuterTyVarBndrs flag pass #

hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr (HsBndrVis pass) pass] #

isHsKindedTyVar :: HsTyVarBndr flag pass -> Bool #

Does this `HsTyVarBndr` come with an explicit kind annotation?