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

Safe Haskell | Ignore
Language | GHC2021

GHC.Hs.Type

Contents

- Orphan instances

Synopsis

- type Mult = Type
- 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)
- multAnnToHsType :: HsMultAnn GhcRn -> Maybe (LHsType GhcRn)
- expandHsMultAnnOf :: (LocatedN Name -> t GhcRn) -> HsMultAnnOf (LocatedA (t GhcRn)) GhcRn -> Maybe (LocatedA (t GhcRn))
- data EpLinear
  - = EpPct1 !(EpToken "%1") !EpArrowOrColon
  - | EpLolly !(EpToken "\8888")
- data EpArrowOrColon
  - = EpArrow !TokRarrow
  - | EpColon !TokDcolon
  - | EpPatBind
- pprHsArrow :: forall mult (pass :: Pass). (Outputable mult, OutputableBndrId pass) => HsMultAnnOf mult (GhcPass pass) -> SDoc
- pprHsMultAnn :: forall (id :: Pass). OutputableBndrId id => HsMultAnn (GhcPass id) -> SDoc
- 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 HsCoreTy = Type
- type LHsType pass = XRec pass (HsType pass)
- type HsKind pass = HsType pass
- type LHsKind pass = XRec pass (HsKind pass)
- data HsTypeGhcPsExt
  - = HsCoreTy HsCoreTy
  - | HsBangTy (EpaLocation, EpToken "#-}", EpaLocation) HsSrcBang (LHsType GhcPs)
  - | HsRecTy (AnnList ()) [LHsConDeclRecField GhcPs]
- 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)
- type EpAnnForallVis = EpAnn (TokForall, TokRarrow)
- type EpAnnForallInvis = EpAnn (TokForall, EpToken ".")
- 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 AnnTyVarBndr = AnnTyVarBndr {
  - atv_opens :: [EpaLocation]
  - atv_closes :: [EpaLocation]
  - atv_tv :: EpToken "'"
  - atv_dcolon :: TokDcolon
  }
- data HsBndrKind pass
  - = HsBndrKind !(XBndrKind pass) (LHsKind pass)
  - | HsBndrNoKind !(XBndrNoKind pass)
  - | XBndrKind !(XXBndrKind pass)
- data HsBndrVar pass
  - = HsBndrVar !(XBndrVar pass) !(LIdP pass)
  - | HsBndrWildCard !(XBndrWildCard pass)
  - | XBndrVar !(XXBndrVar pass)
- data HsBndrVis pass
  - = HsBndrRequired !(XBndrRequired pass)
  - | HsBndrInvisible !(XBndrInvisible pass)
  - | XBndrVis !(XXBndrVis pass)
- isHsBndrInvisible :: HsBndrVis pass -> Bool
- 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 HsPSRn = HsPSRn {
  - hsps_nwcs :: [Name]
  - hsps_imp_tvs :: [Name]
  }
- data HsTyPat pass
  - = HsTP {
    - hstp_ext :: XHsTP pass
    - hstp_body :: LHsType pass
    }
  - | XHsTyPat !(XXHsTyPat pass)
- data HsTyPatRn = HsTPRn {
  - hstp_nwcs :: [Name]
  - hstp_imp_tvs :: [Name]
  - hstp_exp_tvs :: [Name]
  }
- data HsTyPatRnBuilder = HsTPRnB {
  - hstpb_nwcs :: Bag Name
  - hstpb_imp_tvs :: Bag Name
  - hstpb_exp_tvs :: Bag Name
  }
- tpBuilderExplicitTV :: Name -> HsTyPatRnBuilder
- tpBuilderPatSig :: HsPSRn -> HsTyPatRnBuilder
- buildHsTyPatRn :: HsTyPatRnBuilder -> HsTyPatRn
- builderFromHsTyPatRn :: HsTyPatRn -> HsTyPatRnBuilder
- 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 HsTupleSort
  - = HsUnboxedTuple
  - | HsBoxedOrConstraintTuple
- type HsContext pass = [LHsType pass]
- type LHsContext pass = XRec pass (HsContext pass)
- fromMaybeContext :: forall (p :: Pass). Maybe (LHsContext (GhcPass p)) -> HsContext (GhcPass p)
- 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)
- numVisibleArgs :: [HsArg p tm ty] -> Arity
- pprHsArgsApp :: forall id tm ty (p :: Pass). (OutputableBndr id, Outputable tm, Outputable ty) => id -> LexicalFixity -> [HsArg (GhcPass p) tm ty] -> SDoc
- type LHsTypeArg p = HsArg p (LHsType p) (LHsKind p)
- lhsTypeArgSrcSpan :: LHsTypeArg GhcPs -> SrcSpan
- class OutputableBndrFlag flag (p :: Pass)
- data HsSrcBang = HsSrcBang SourceText SrcUnpackedness SrcStrictness
- data HsImplBang
  - = HsLazy
  - | HsStrict Bool
  - | HsUnpack (Maybe Coercion)
- data SrcStrictness
  - = SrcLazy
  - | SrcStrict
  - | NoSrcStrict
- data SrcUnpackedness
  - = SrcUnpack
  - | SrcNoUnpack
  - | NoSrcUnpack
- 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)
- pprHsConDeclRecFields :: forall (p :: Pass). OutputableBndrId p => [LHsConDeclRecField (GhcPass p)] -> SDoc
- 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)
  }
- pprHsConDeclFieldWith :: forall (p :: Pass). OutputableBndrId p => (HsMultAnn (GhcPass p) -> SDoc -> SDoc) -> HsConDeclField (GhcPass p) -> SDoc
- pprHsConDeclFieldNoMult :: forall (p :: Pass). OutputableBndrId p => HsConDeclField (GhcPass p) -> SDoc
- hsPlainTypeField :: LHsType GhcPs -> HsConDeclField GhcPs
- mkConDeclField :: HsMultAnn GhcPs -> LHsType GhcPs -> HsConDeclField GhcPs
- data FieldOcc pass
  - = FieldOcc {
    - foExt :: XCFieldOcc pass
    - foLabel :: LIdP pass
    }
  - | XFieldOcc !(XXFieldOcc pass)
- type LFieldOcc pass = XRec pass (FieldOcc pass)
- mkFieldOcc :: LocatedN RdrName -> FieldOcc GhcPs
- fieldOccRdrName :: forall (p :: Pass). IsPass p => FieldOcc (GhcPass p) -> RdrName
- fieldOccLRdrName :: forall (p :: Pass). IsPass p => FieldOcc (GhcPass p) -> LocatedN RdrName
- data OpName
  - = NormalOp (WithUserRdr Name)
  - | NegateOp
  - | UnboundOp RdrName
  - | RecFldOp (FieldOcc GhcRn)
- mkAnonWildCardTy :: EpToken "_" -> HsType GhcPs
- pprAnonWildCard :: SDoc
- hsOuterTyVarNames :: HsOuterTyVarBndrs flag GhcRn -> [Name]
- hsOuterExplicitBndrs :: forall flag (p :: Pass). HsOuterTyVarBndrs flag (GhcPass p) -> [LHsTyVarBndr flag (NoGhcTc (GhcPass p))]
- mapHsOuterImplicit :: (XHsOuterImplicit pass -> XHsOuterImplicit pass) -> HsOuterTyVarBndrs flag pass -> HsOuterTyVarBndrs flag pass
- mkHsOuterImplicit :: HsOuterTyVarBndrs flag GhcPs
- mkHsOuterExplicit :: EpAnnForallInvis -> [LHsTyVarBndr flag GhcPs] -> HsOuterTyVarBndrs flag GhcPs
- mkHsImplicitSigType :: LHsType GhcPs -> HsSigType GhcPs
- mkHsExplicitSigType :: EpAnnForallInvis -> [LHsTyVarBndr Specificity GhcPs] -> LHsType GhcPs -> HsSigType GhcPs
- mkHsWildCardBndrs :: thing -> HsWildCardBndrs GhcPs thing
- mkHsPatSigType :: EpAnnCO -> LHsType GhcPs -> HsPatSigType GhcPs
- mkHsTyPat :: LHsType GhcPs -> HsTyPat GhcPs
- mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs GhcRn thing
- mkHsForAllVisTele :: forall (p :: Pass). EpAnnForallVis -> [LHsTyVarBndr () (GhcPass p)] -> HsForAllTelescope (GhcPass p)
- mkHsForAllInvisTele :: forall (p :: Pass). EpAnnForallInvis -> [LHsTyVarBndr Specificity (GhcPass p)] -> HsForAllTelescope (GhcPass p)
- mkHsQTvs :: [LHsTyVarBndr (HsBndrVis GhcPs) GhcPs] -> LHsQTyVars GhcPs
- hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr (HsBndrVis pass) pass]
- emptyLHsQTvs :: LHsQTyVars GhcRn
- isHsKindedTyVar :: HsTyVarBndr flag pass -> Bool
- hsBndrVar :: forall flag (pass :: Pass). HsTyVarBndr flag (GhcPass pass) -> HsBndrVar (GhcPass pass)
- hsBndrKind :: forall flag (pass :: Pass). HsTyVarBndr flag (GhcPass pass) -> HsBndrKind (GhcPass pass)
- hsTvbAllKinded :: forall (p :: Pass). LHsQTyVars (GhcPass p) -> Bool
- hsScopedTvs :: LHsSigType GhcRn -> [Name]
- hsScopedKvs :: LHsKind GhcRn -> [Name]
- hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name]
- dropWildCards :: forall (p :: Pass). LHsSigWcType (GhcPass p) -> LHsSigType (GhcPass p)
- hsTyVarLName :: forall flag (p :: Pass). HsTyVarBndr flag (GhcPass p) -> Maybe (LIdP (GhcPass p))
- hsTyVarName :: forall flag (p :: Pass). HsTyVarBndr flag (GhcPass p) -> Maybe (IdP (GhcPass p))
- hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name]
- hsLTyVarLocNames :: forall (p :: Pass). Anno (IdGhcP p) ~ SrcSpanAnnN => LHsQTyVars (GhcPass p) -> [LocatedN (IdP (GhcPass p))]
- hsLTyVarName :: forall flag (p :: Pass). LHsTyVarBndr flag (GhcPass p) -> Maybe (IdP (GhcPass p))
- hsLTyVarNames :: forall flag (p :: Pass). [LHsTyVarBndr flag (GhcPass p)] -> [IdP (GhcPass p)]
- hsForAllTelescopeBndrs :: forall (p :: Pass). HsForAllTelescope (GhcPass p) -> [LHsTyVarBndr ForAllTyFlag (GhcPass p)]
- hsForAllTelescopeNames :: forall (p :: Pass). HsForAllTelescope (GhcPass p) -> [IdP (GhcPass p)]
- hsLTyVarLocName :: forall (p :: Pass) flag. Anno (IdGhcP p) ~ SrcSpanAnnN => LHsTyVarBndr flag (GhcPass p) -> Maybe (LocatedN (IdP (GhcPass p)))
- hsExplicitLTyVarNames :: forall (p :: Pass). LHsQTyVars (GhcPass p) -> [IdP (GhcPass p)]
- splitLHsInstDeclTy :: LHsSigType GhcRn -> ([Name], Maybe (LHsContext GhcRn), LHsType GhcRn)
- getLHsInstDeclHead :: forall (p :: Pass). LHsSigType (GhcPass p) -> LHsType (GhcPass p)
- getLHsInstDeclClass_maybe :: forall (p :: Pass). Anno (IdOccGhcP p) ~ SrcSpanAnnN => LHsSigType (GhcPass p) -> Maybe (LocatedN (IdOccP (GhcPass p)))
- splitLHsPatSynTy :: forall (p :: Pass). LHsSigType (GhcPass p) -> ([LHsTyVarBndr Specificity (GhcPass (NoGhcTcPass p))], Maybe (LHsContext (GhcPass p)), [LHsTyVarBndr Specificity (GhcPass p)], Maybe (LHsContext (GhcPass p)), LHsType (GhcPass p))
- splitLHsForAllTyInvis :: forall (pass :: Pass). LHsType (GhcPass pass) -> ([LHsTyVarBndr Specificity (GhcPass pass)], LHsType (GhcPass pass))
- splitLHsForAllTyInvis_KP :: forall (pass :: Pass). LHsType (GhcPass pass) -> (Maybe [LHsTyVarBndr Specificity (GhcPass pass)], LHsType (GhcPass pass))
- splitLHsQualTy :: forall (pass :: Pass). LHsType (GhcPass pass) -> (Maybe (LHsContext (GhcPass pass)), LHsType (GhcPass pass))
- splitLHsSigmaTyInvis :: forall (p :: Pass). LHsType (GhcPass p) -> ([LHsTyVarBndr Specificity (GhcPass p)], Maybe (LHsContext (GhcPass p)), LHsType (GhcPass p))
- splitLHsGadtTy :: LHsSigType GhcPs -> (HsOuterSigTyVarBndrs GhcPs, [HsForAllTelescope GhcPs], Maybe (LHsContext GhcPs), LHsType GhcPs)
- splitHsFunType :: LHsType GhcPs -> (([EpToken "("], [EpToken ")"]), EpAnnComments, [HsConDeclField GhcPs], LHsType GhcPs)
- hsTyGetAppHead_maybe :: forall (p :: Pass). Anno (IdOccGhcP p) ~ SrcSpanAnnN => LHsType (GhcPass p) -> Maybe (LocatedN (IdOccP (GhcPass p)))
- mkHsOpTy :: forall (p :: Pass). Anno (IdOccGhcP p) ~ SrcSpanAnnN => PromotionFlag -> LHsType (GhcPass p) -> LocatedN (IdOccP (GhcPass p)) -> LHsType (GhcPass p) -> HsType (GhcPass p)
- mkHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
- mkHsAppTys :: forall (p :: Pass). LHsType (GhcPass p) -> [LHsType (GhcPass p)] -> LHsType (GhcPass p)
- mkHsAppKindTy :: forall (p :: Pass). XAppKindTy (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
- ignoreParens :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p)
- hsSigWcType :: forall (p :: Pass). LHsSigWcType (GhcPass p) -> LHsType (GhcPass p)
- hsPatSigType :: forall (p :: Pass). HsPatSigType (GhcPass p) -> LHsType (GhcPass p)
- hsTyKindSig :: forall (p :: Pass). LHsType (GhcPass p) -> Maybe (LHsKind (GhcPass p))
- setHsTyVarBndrFlag :: forall flag flag' (pass :: Pass). flag -> HsTyVarBndr flag' (GhcPass pass) -> HsTyVarBndr flag (GhcPass pass)
- hsTyVarBndrFlag :: forall flag (pass :: Pass). HsTyVarBndr flag (GhcPass pass) -> flag
- updateHsTyVarBndrFlag :: forall flag flag' (pass :: Pass). (flag -> flag') -> HsTyVarBndr flag (GhcPass pass) -> HsTyVarBndr flag' (GhcPass pass)
- pprHsType :: forall (p :: Pass). OutputableBndrId p => HsType (GhcPass p) -> SDoc
- pprHsForAll :: forall (p :: Pass). OutputableBndrId p => HsForAllTelescope (GhcPass p) -> Maybe (LHsContext (GhcPass p)) -> SDoc
- pprHsForAllTelescope :: forall (p :: Pass). OutputableBndrId p => HsForAllTelescope (GhcPass p) -> SDoc
- pprHsOuterFamEqnTyVarBndrs :: forall (p :: Pass). OutputableBndrId p => HsOuterFamEqnTyVarBndrs (GhcPass p) -> SDoc
- pprHsOuterSigTyVarBndrs :: forall (p :: Pass). OutputableBndrId p => HsOuterSigTyVarBndrs (GhcPass p) -> SDoc
- pprLHsContext :: forall (p :: Pass). OutputableBndrId p => Maybe (LHsContext (GhcPass p)) -> SDoc
- hsTypeNeedsParens :: forall (p :: Pass). IsPass p => PprPrec -> HsType (GhcPass p) -> Bool
- parenthesizeHsType :: forall (p :: Pass). IsPass p => PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p)
- parenthesizeHsContext :: forall (p :: Pass). IsPass p => PprPrec -> LHsContext (GhcPass p) -> LHsContext (GhcPass p)

# Documentation

type Mult = Type #

Mult is a type alias for Type.

Mult must contain Type because multiplicity variables are mere type variables (of kind Multiplicity) in Haskell. So the simplest implementation is to make Mult be Type.

Multiplicities can be formed with: - One: GHC.Types.One (= oneDataCon) - Many: GHC.Types.Many (= manyDataCon) - Multiplication: GHC.Types.MultMul (= multMulTyCon)

So that Mult feels a bit more structured, we provide pattern synonyms and smart constructors for these.

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 #

multAnnToHsType :: HsMultAnn GhcRn -> Maybe (LHsType GhcRn) #

expandHsMultAnnOf :: (LocatedN Name -> t GhcRn) -> HsMultAnnOf (LocatedA (t GhcRn)) GhcRn -> Maybe (LocatedA (t GhcRn)) #

Convert an multiplicity annotation into its corresponding multiplicity. If no annotation was written, `Nothing` is returned. In this polymorphic function, `t` can be `HsType` or `HsExpr`

data EpLinear #

Constructors

EpPct1 !(EpToken "%1") !EpArrowOrColon |
EpLolly !(EpToken "\8888") |

#### Instances

Instances details

Data EpLinear # |
Instance details Defined in GHC.Hs.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EpLinear -> c EpLinear # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EpLinear # toConstr :: EpLinear -> Constr # dataTypeOf :: EpLinear -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EpLinear) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EpLinear) # gmapT :: (forall b. Data b => b -> b) -> EpLinear -> EpLinear # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EpLinear -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EpLinear -> r # gmapQ :: (forall d. Data d => d -> u) -> EpLinear -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EpLinear -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EpLinear -> m EpLinear # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EpLinear -> m EpLinear # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EpLinear -> m EpLinear #
NoAnn EpLinear # |
Instance details Defined in GHC.Hs.Type Methods noAnn :: EpLinear #

data EpArrowOrColon #

Constructors

EpArrow !TokRarrow |
EpColon !TokDcolon |
EpPatBind |

#### Instances

Instances details

Data EpArrowOrColon # |
Instance details Defined in GHC.Hs.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EpArrowOrColon -> c EpArrowOrColon # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EpArrowOrColon # toConstr :: EpArrowOrColon -> Constr # dataTypeOf :: EpArrowOrColon -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EpArrowOrColon) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EpArrowOrColon) # gmapT :: (forall b. Data b => b -> b) -> EpArrowOrColon -> EpArrowOrColon # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EpArrowOrColon -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EpArrowOrColon -> r # gmapQ :: (forall d. Data d => d -> u) -> EpArrowOrColon -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EpArrowOrColon -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EpArrowOrColon -> m EpArrowOrColon # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EpArrowOrColon -> m EpArrowOrColon # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EpArrowOrColon -> m EpArrowOrColon #

pprHsArrow :: forall mult (pass :: Pass). (Outputable mult, OutputableBndrId pass) => HsMultAnnOf mult (GhcPass pass) -> SDoc #

pprHsMultAnn :: forall (id :: Pass). OutputableBndrId id => HsMultAnn (GhcPass id) -> SDoc #

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 HsCoreTy = Type #

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 HsTypeGhcPsExt #

Constructors

HsCoreTy HsCoreTy |
HsBangTy (EpaLocation, EpToken "#-}", EpaLocation) HsSrcBang (LHsType GhcPs) |
HsRecTy (AnnList ()) [LHsConDeclRecField GhcPs] |

#### Instances

Instances details

Data HsTypeGhcPsExt # |
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) -> HsTypeGhcPsExt -> c HsTypeGhcPsExt # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsTypeGhcPsExt # toConstr :: HsTypeGhcPsExt -> Constr # dataTypeOf :: HsTypeGhcPsExt -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsTypeGhcPsExt) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsTypeGhcPsExt) # gmapT :: (forall b. Data b => b -> b) -> HsTypeGhcPsExt -> HsTypeGhcPsExt # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTypeGhcPsExt -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTypeGhcPsExt -> r # gmapQ :: (forall d. Data d => d -> u) -> HsTypeGhcPsExt -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTypeGhcPsExt -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTypeGhcPsExt -> m HsTypeGhcPsExt # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTypeGhcPsExt -> m HsTypeGhcPsExt # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTypeGhcPsExt -> m HsTypeGhcPsExt #

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 #

type EpAnnForallVis = EpAnn (TokForall, TokRarrow) #

type EpAnnForallInvis = EpAnn (TokForall, EpToken ".") #

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 AnnTyVarBndr #

Constructors

AnnTyVarBndr |
Fields atv_opens :: [EpaLocation] atv_closes :: [EpaLocation] atv_tv :: EpToken "'" atv_dcolon :: TokDcolon

#### Instances

Instances details

Data AnnTyVarBndr # |
Instance details Defined in GHC.Hs.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnTyVarBndr -> c AnnTyVarBndr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnTyVarBndr # toConstr :: AnnTyVarBndr -> Constr # dataTypeOf :: AnnTyVarBndr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnTyVarBndr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTyVarBndr) # gmapT :: (forall b. Data b => b -> b) -> AnnTyVarBndr -> AnnTyVarBndr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnTyVarBndr -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnTyVarBndr -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnTyVarBndr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnTyVarBndr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnTyVarBndr -> m AnnTyVarBndr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTyVarBndr -> m AnnTyVarBndr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTyVarBndr -> m AnnTyVarBndr #
NoAnn AnnTyVarBndr # |
Instance details Defined in GHC.Hs.Type Methods noAnn :: AnnTyVarBndr #

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) #

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 #

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

isHsBndrInvisible :: HsBndrVis pass -> Bool #

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 HsPSRn #

The extension field for `HsPatSigType`, which is only used in the renamer onwards. See `Note [Pattern signature binders and scoping]`.

Constructors

HsPSRn |
Fields hsps_nwcs :: [Name] Wildcard names hsps_imp_tvs :: [Name] Implicitly bound variable names

#### Instances

Instances details

Data HsPSRn # |
Instance details Defined in GHC.Hs.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsPSRn -> c HsPSRn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsPSRn # toConstr :: HsPSRn -> Constr # dataTypeOf :: HsPSRn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsPSRn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsPSRn) # gmapT :: (forall b. Data b => b -> b) -> HsPSRn -> HsPSRn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsPSRn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsPSRn -> r # gmapQ :: (forall d. Data d => d -> u) -> HsPSRn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsPSRn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsPSRn -> m HsPSRn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPSRn -> m HsPSRn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsPSRn -> m HsPSRn #

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 #

data HsTyPatRn #

Constructors

HsTPRn |
Fields hstp_nwcs :: [Name] Wildcard names hstp_imp_tvs :: [Name] Implicitly bound variable names hstp_exp_tvs :: [Name] Explicitly bound variable names

#### Instances

Instances details

Data HsTyPatRn # |
Instance details Defined in GHC.Hs.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyPatRn -> c HsTyPatRn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsTyPatRn # toConstr :: HsTyPatRn -> Constr # dataTypeOf :: HsTyPatRn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsTyPatRn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsTyPatRn) # gmapT :: (forall b. Data b => b -> b) -> HsTyPatRn -> HsTyPatRn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyPatRn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyPatRn -> r # gmapQ :: (forall d. Data d => d -> u) -> HsTyPatRn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyPatRn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyPatRn -> m HsTyPatRn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyPatRn -> m HsTyPatRn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyPatRn -> m HsTyPatRn #

data HsTyPatRnBuilder #

A variant of HsTyPatRn that uses Bags for efficient concatenation. See Note [Implicit and explicit type variable binders] in GHC.Rename.Pat

Constructors

HsTPRnB |
Fields hstpb_nwcs :: Bag Name hstpb_imp_tvs :: Bag Name hstpb_exp_tvs :: Bag Name

#### Instances

Instances details

Monoid HsTyPatRnBuilder # |
Instance details Defined in GHC.Hs.Type Methods mempty :: HsTyPatRnBuilder # mappend :: HsTyPatRnBuilder -> HsTyPatRnBuilder -> HsTyPatRnBuilder # mconcat :: [HsTyPatRnBuilder] -> HsTyPatRnBuilder #
Semigroup HsTyPatRnBuilder # |
Instance details Defined in GHC.Hs.Type Methods (<>) :: HsTyPatRnBuilder -> HsTyPatRnBuilder -> HsTyPatRnBuilder # sconcat :: NonEmpty HsTyPatRnBuilder -> HsTyPatRnBuilder # stimes :: Integral b => b -> HsTyPatRnBuilder -> HsTyPatRnBuilder #

tpBuilderExplicitTV :: Name -> HsTyPatRnBuilder #

tpBuilderPatSig :: HsPSRn -> HsTyPatRnBuilder #

buildHsTyPatRn :: HsTyPatRnBuilder -> HsTyPatRn #

builderFromHsTyPatRn :: HsTyPatRn -> HsTyPatRnBuilder #

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 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

fromMaybeContext :: forall (p :: Pass). Maybe (LHsContext (GhcPass p)) -> HsContext (GhcPass p) #

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 #

numVisibleArgs :: [HsArg p tm ty] -> Arity #

pprHsArgsApp :: forall id tm ty (p :: Pass). (OutputableBndr id, Outputable tm, Outputable ty) => id -> LexicalFixity -> [HsArg (GhcPass p) tm ty] -> SDoc #

``pprHsArgsApp` id fixity args` pretty-prints an application of `id` to `args`, using the `fixity` to tell whether `id` should be printed prefix or infix. Examples:

    pprHsArgsApp T Prefix [HsTypeArg Bool, HsValArg Int]                        = T @Bool Int
    pprHsArgsApp T Prefix [HsTypeArg Bool, HsArgPar, HsValArg Int]              = (T @Bool) Int
    pprHsArgsApp (++) Infix [HsValArg Char, HsValArg Double]                    = Char ++ Double
    pprHsArgsApp (++) Infix [HsValArg Char, HsValArg Double, HsVarArg Ordering] = (Char ++ Double) Ordering

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

lhsTypeArgSrcSpan :: LHsTypeArg GhcPs -> SrcSpan #

Compute the `SrcSpan` associated with an `LHsTypeArg`.

class OutputableBndrFlag flag (p :: Pass) #

Minimal complete definition

pprTyVarBndr

#### Instances

Instances details

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

data HsSrcBang #

Haskell Source Bang

Bangs on data constructor arguments as written by the user, including the source code for exact-printing.

`(HsSrcBang _ SrcUnpack SrcLazy)` and `(HsSrcBang _ SrcUnpack NoSrcStrict)` (without StrictData) makes no sense, we emit a warning (in checkValidDataCon) and treat it like `(HsSrcBang _ NoSrcUnpack SrcLazy)`

In the AST, the `SourceText` is hidden inside the extension point `XConDeclField`.

Constructors

HsSrcBang SourceText SrcUnpackedness SrcStrictness |

#### Instances

Instances details

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

data HsImplBang #

Haskell Implementation Bang

Bangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.

Constructors

HsLazy | Lazy field, or one with an unlifted type
HsStrict Bool | Strict but not unpacked field True = we could have unpacked, but opted not to because of -O0. See Note [Detecting useless UNPACK pragmas]
HsUnpack (Maybe Coercion) | Strict and unpacked field co :: arg-ty ~ product-ty HsBang

#### Instances

Instances details

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

data SrcStrictness #

Source Strictness

What strictness annotation the user wrote

Constructors

SrcLazy | Lazy, ie `~`
SrcStrict | Strict, ie `!`
NoSrcStrict | no strictness annotation

#### Instances

Instances details

NFData SrcStrictness # |
Instance details Defined in GHC.Core.DataCon Methods rnf :: SrcStrictness -> () #
Data SrcStrictness # |
Instance details Defined in Language.Haskell.Syntax.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcStrictness -> c SrcStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcStrictness # toConstr :: SrcStrictness -> Constr # dataTypeOf :: SrcStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcStrictness) # gmapT :: (forall b. Data b => b -> b) -> SrcStrictness -> SrcStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness #
Binary SrcStrictness # |
Instance details Defined in GHC.Core.DataCon Methods put_ :: WriteBinHandle -> SrcStrictness -> IO () # put :: WriteBinHandle -> SrcStrictness -> IO (Bin SrcStrictness) # get :: ReadBinHandle -> IO SrcStrictness #
Outputable SrcStrictness # |
Instance details Defined in GHC.Core.DataCon Methods ppr :: SrcStrictness -> SDoc #
Eq SrcStrictness # |
Instance details Defined in Language.Haskell.Syntax.Basic Methods (==) :: SrcStrictness -> SrcStrictness -> Bool # (/=) :: SrcStrictness -> SrcStrictness -> Bool #

data SrcUnpackedness #

Source Unpackedness

What unpackedness the user requested

Constructors

SrcUnpack | {-# UNPACK #-} specified
SrcNoUnpack | {-# NOUNPACK #-} specified
NoSrcUnpack | no unpack pragma

#### Instances

Instances details

NFData SrcUnpackedness # |
Instance details Defined in GHC.Core.DataCon Methods rnf :: SrcUnpackedness -> () #
Data SrcUnpackedness # |
Instance details Defined in Language.Haskell.Syntax.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcUnpackedness -> c SrcUnpackedness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcUnpackedness # toConstr :: SrcUnpackedness -> Constr # dataTypeOf :: SrcUnpackedness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcUnpackedness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcUnpackedness) # gmapT :: (forall b. Data b => b -> b) -> SrcUnpackedness -> SrcUnpackedness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcUnpackedness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcUnpackedness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness #
Binary SrcUnpackedness # |
Instance details Defined in GHC.Core.DataCon Methods put_ :: WriteBinHandle -> SrcUnpackedness -> IO () # put :: WriteBinHandle -> SrcUnpackedness -> IO (Bin SrcUnpackedness) # get :: ReadBinHandle -> IO SrcUnpackedness #
Outputable SrcUnpackedness # |
Instance details Defined in GHC.Core.DataCon Methods ppr :: SrcUnpackedness -> SDoc #
Eq SrcUnpackedness # |
Instance details Defined in Language.Haskell.Syntax.Basic Methods (==) :: SrcUnpackedness -> SrcUnpackedness -> Bool # (/=) :: SrcUnpackedness -> SrcUnpackedness -> 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

pprHsConDeclRecFields :: forall (p :: Pass). OutputableBndrId p => [LHsConDeclRecField (GhcPass p)] -> SDoc #

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) #

pprHsConDeclFieldWith :: forall (p :: Pass). OutputableBndrId p => (HsMultAnn (GhcPass p) -> SDoc -> SDoc) -> HsConDeclField (GhcPass p) -> SDoc #

pprHsConDeclFieldNoMult :: forall (p :: Pass). OutputableBndrId p => HsConDeclField (GhcPass p) -> SDoc #

hsPlainTypeField :: LHsType GhcPs -> HsConDeclField GhcPs #

mkConDeclField :: HsMultAnn GhcPs -> LHsType GhcPs -> HsConDeclField GhcPs #

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

mkFieldOcc :: LocatedN RdrName -> FieldOcc GhcPs #

fieldOccRdrName :: forall (p :: Pass). IsPass p => FieldOcc (GhcPass p) -> RdrName #

fieldOccLRdrName :: forall (p :: Pass). IsPass p => FieldOcc (GhcPass p) -> LocatedN RdrName #

data OpName #

Name of an operator in an operator application or section

Constructors

NormalOp (WithUserRdr Name) | A normal identifier
NegateOp | Prefix negation
UnboundOp RdrName | An unbound identifier
RecFldOp (FieldOcc GhcRn) | A record field occurrence

#### Instances

Instances details

Outputable OpName # |
Instance details Defined in GHC.Hs.Type Methods ppr :: OpName -> SDoc #

mkAnonWildCardTy :: EpToken "_" -> HsType GhcPs #

pprAnonWildCard :: SDoc #

hsOuterTyVarNames :: HsOuterTyVarBndrs flag GhcRn -> [Name] #

hsOuterExplicitBndrs :: forall flag (p :: Pass). HsOuterTyVarBndrs flag (GhcPass p) -> [LHsTyVarBndr flag (NoGhcTc (GhcPass p))] #

mapHsOuterImplicit :: (XHsOuterImplicit pass -> XHsOuterImplicit pass) -> HsOuterTyVarBndrs flag pass -> HsOuterTyVarBndrs flag pass #

mkHsOuterImplicit :: HsOuterTyVarBndrs flag GhcPs #

mkHsOuterExplicit :: EpAnnForallInvis -> [LHsTyVarBndr flag GhcPs] -> HsOuterTyVarBndrs flag GhcPs #

mkHsImplicitSigType :: LHsType GhcPs -> HsSigType GhcPs #

mkHsExplicitSigType :: EpAnnForallInvis -> [LHsTyVarBndr Specificity GhcPs] -> LHsType GhcPs -> HsSigType GhcPs #

mkHsWildCardBndrs :: thing -> HsWildCardBndrs GhcPs thing #

mkHsPatSigType :: EpAnnCO -> LHsType GhcPs -> HsPatSigType GhcPs #

mkHsTyPat :: LHsType GhcPs -> HsTyPat GhcPs #

mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs GhcRn thing #

mkHsForAllVisTele :: forall (p :: Pass). EpAnnForallVis -> [LHsTyVarBndr () (GhcPass p)] -> HsForAllTelescope (GhcPass p) #

mkHsForAllInvisTele :: forall (p :: Pass). EpAnnForallInvis -> [LHsTyVarBndr Specificity (GhcPass p)] -> HsForAllTelescope (GhcPass p) #

mkHsQTvs :: [LHsTyVarBndr (HsBndrVis GhcPs) GhcPs] -> LHsQTyVars GhcPs #

hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr (HsBndrVis pass) pass] #

emptyLHsQTvs :: LHsQTyVars GhcRn #

isHsKindedTyVar :: HsTyVarBndr flag pass -> Bool #

Does this `HsTyVarBndr` come with an explicit kind annotation?

hsBndrVar :: forall flag (pass :: Pass). HsTyVarBndr flag (GhcPass pass) -> HsBndrVar (GhcPass pass) #

Get the variable of the type variable binder

hsBndrKind :: forall flag (pass :: Pass). HsTyVarBndr flag (GhcPass pass) -> HsBndrKind (GhcPass pass) #

Get the kind of the type variable binder

hsTvbAllKinded :: forall (p :: Pass). LHsQTyVars (GhcPass p) -> Bool #

Do all type variables in this `LHsQTyVars` come with kind annotations?

hsScopedTvs :: LHsSigType GhcRn -> [Name] #

hsScopedKvs :: LHsKind GhcRn -> [Name] #

hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name] #

dropWildCards :: forall (p :: Pass). LHsSigWcType (GhcPass p) -> LHsSigType (GhcPass p) #

hsTyVarLName :: forall flag (p :: Pass). HsTyVarBndr flag (GhcPass p) -> Maybe (LIdP (GhcPass p)) #

hsTyVarName :: forall flag (p :: Pass). HsTyVarBndr flag (GhcPass p) -> Maybe (IdP (GhcPass p)) #

hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name] #

hsLTyVarLocNames :: forall (p :: Pass). Anno (IdGhcP p) ~ SrcSpanAnnN => LHsQTyVars (GhcPass p) -> [LocatedN (IdP (GhcPass p))] #

hsLTyVarName :: forall flag (p :: Pass). LHsTyVarBndr flag (GhcPass p) -> Maybe (IdP (GhcPass p)) #

hsLTyVarNames :: forall flag (p :: Pass). [LHsTyVarBndr flag (GhcPass p)] -> [IdP (GhcPass p)] #

hsForAllTelescopeBndrs :: forall (p :: Pass). HsForAllTelescope (GhcPass p) -> [LHsTyVarBndr ForAllTyFlag (GhcPass p)] #

hsForAllTelescopeNames :: forall (p :: Pass). HsForAllTelescope (GhcPass p) -> [IdP (GhcPass p)] #

hsLTyVarLocName :: forall (p :: Pass) flag. Anno (IdGhcP p) ~ SrcSpanAnnN => LHsTyVarBndr flag (GhcPass p) -> Maybe (LocatedN (IdP (GhcPass p))) #

hsExplicitLTyVarNames :: forall (p :: Pass). LHsQTyVars (GhcPass p) -> [IdP (GhcPass p)] #

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

Decompose a type class instance type (of the form `forall tvs. context => instance_head`) into its constituent parts. Note that the `[Name]`s returned correspond to either:

- The implicitly bound type variables (if the type lacks an outermost `forall`), or
- The explicitly bound type variables (if the type has an outermost `forall`).

This function is careful not to look through parentheses. See `Note [No nested foralls or contexts in instance types]` for why this is important.

getLHsInstDeclHead :: forall (p :: Pass). LHsSigType (GhcPass p) -> LHsType (GhcPass p) #

Decompose a type class instance type (of the form `forall tvs. context => instance_head`) into the `instance_head`.

getLHsInstDeclClass_maybe :: forall (p :: Pass). Anno (IdOccGhcP p) ~ SrcSpanAnnN => LHsSigType (GhcPass p) -> Maybe (LocatedN (IdOccP (GhcPass p))) #

Decompose a type class instance type (of the form `forall tvs. context => instance_head`) into the `instance_head` and retrieve the underlying class type constructor (if it exists).

splitLHsPatSynTy :: forall (p :: Pass). LHsSigType (GhcPass p) -> ([LHsTyVarBndr Specificity (GhcPass (NoGhcTcPass p))], Maybe (LHsContext (GhcPass p)), [LHsTyVarBndr Specificity (GhcPass p)], Maybe (LHsContext (GhcPass p)), LHsType (GhcPass p)) #

Decompose a pattern synonym type signature into its constituent parts.

Note that this function looks through parentheses, so it will work on types such as `(forall a. ...)`. The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

splitLHsForAllTyInvis :: forall (pass :: Pass). LHsType (GhcPass pass) -> ([LHsTyVarBndr Specificity (GhcPass pass)], LHsType (GhcPass pass)) #

Decompose a type of the form `forall tvs. body` into its constituent parts. Only splits type variable binders that were quantified invisibly (e.g., `forall a.`, with a dot).

This function is used to split apart certain types, such as instance declaration types, which disallow visible `forall`s. For instance, if GHC split apart the `forall` in `instance forall a -> Show (Blah a)`, then that declaration would mistakenly be accepted!

Note that this function looks through parentheses, so it will work on types such as `(forall a. ...)`. The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them. Unlike `splitLHsSigmaTyInvis`, this function does not look through parentheses, hence the suffix `_KP` (short for "Keep Parentheses").

splitLHsForAllTyInvis_KP :: forall (pass :: Pass). LHsType (GhcPass pass) -> (Maybe [LHsTyVarBndr Specificity (GhcPass pass)], LHsType (GhcPass pass)) #

Decompose a type of the form `forall tvs. body` into its constituent parts. Only splits type variable binders that were quantified invisibly (e.g., `forall a.`, with a dot).

This function is used to split apart certain types, such as instance declaration types, which disallow visible `forall`s. For instance, if GHC split apart the `forall` in `instance forall a -> Show (Blah a)`, then that declaration would mistakenly be accepted!

Unlike `splitLHsForAllTyInvis`, this function does not look through parentheses, hence the suffix `_KP` (short for "Keep Parentheses").

splitLHsQualTy :: forall (pass :: Pass). LHsType (GhcPass pass) -> (Maybe (LHsContext (GhcPass pass)), LHsType (GhcPass pass)) #

Decompose a type of the form `context => body` into its constituent parts.

Note that this function looks through parentheses, so it will work on types such as `(context => ...)`. The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

splitLHsSigmaTyInvis :: forall (p :: Pass). LHsType (GhcPass p) -> ([LHsTyVarBndr Specificity (GhcPass p)], Maybe (LHsContext (GhcPass p)), LHsType (GhcPass p)) #

Decompose a sigma type (of the form `forall tvs. context => body`) into its constituent parts. Only splits type variable binders that were quantified invisibly (e.g., `forall a.`, with a dot).

This function is used to split apart certain types, such as instance declaration types, which disallow visible `forall`s. For instance, if GHC split apart the `forall` in `instance forall a -> Show (Blah a)`, then that declaration would mistakenly be accepted!

Note that this function looks through parentheses, so it will work on types such as `(forall a. ...)`. The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

splitLHsGadtTy :: LHsSigType GhcPs -> (HsOuterSigTyVarBndrs GhcPs, [HsForAllTelescope GhcPs], Maybe (LHsContext GhcPs), LHsType GhcPs) #

Decompose a GADT type into its constituent parts. Returns `(outer_bndrs, mb_ctxt, body)`, where:

- `outer_bndrs` are `HsOuterExplicit` if the type has explicit, outermost type variable binders. Otherwise, they are `HsOuterImplicit`.
- `mb_ctxt` is `Just` the context, if it is provided. Otherwise, it is `Nothing`.
- `body` is the body of the type after the optional `forall`s and context.

This function is careful not to look through parentheses. See `Note [GADT abstract syntax] (Wrinkle: No nested foralls or contexts)` GHC.Hs.Decls for why this is important.

splitHsFunType :: LHsType GhcPs -> (([EpToken "("], [EpToken ")"]), EpAnnComments, [HsConDeclField GhcPs], LHsType GhcPs) #

hsTyGetAppHead_maybe :: forall (p :: Pass). Anno (IdOccGhcP p) ~ SrcSpanAnnN => LHsType (GhcPass p) -> Maybe (LocatedN (IdOccP (GhcPass p))) #

Retrieve the name of the "head" of a nested type application. This is somewhat like `GHC.Tc.Gen.HsType.splitHsAppTys`, but a little more thorough. The purpose of this function is to examine instance heads, so it doesn't handle *all* cases (like lists, tuples, `(~)`, etc.).

mkHsOpTy :: forall (p :: Pass). Anno (IdOccGhcP p) ~ SrcSpanAnnN => PromotionFlag -> LHsType (GhcPass p) -> LocatedN (IdOccP (GhcPass p)) -> LHsType (GhcPass p) -> HsType (GhcPass p) #

mkHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

mkHsAppTys :: forall (p :: Pass). LHsType (GhcPass p) -> [LHsType (GhcPass p)] -> LHsType (GhcPass p) #

mkHsAppKindTy :: forall (p :: Pass). XAppKindTy (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

ignoreParens :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) #

hsSigWcType :: forall (p :: Pass). LHsSigWcType (GhcPass p) -> LHsType (GhcPass p) #

hsPatSigType :: forall (p :: Pass). HsPatSigType (GhcPass p) -> LHsType (GhcPass p) #

hsTyKindSig :: forall (p :: Pass). LHsType (GhcPass p) -> Maybe (LHsKind (GhcPass p)) #

Get the kind signature of a type, ignoring parentheses:

hsTyKindSig `Maybe ` = Nothing hsTyKindSig `Maybe :: Type -> Type ` = Just `Type -> Type` hsTyKindSig `Maybe :: ((Type -> Type))` = Just `Type -> Type`

This is used to extract the result kind of type synonyms with a CUSK:

type S = (F :: res_kind) ^^^^^^^^

setHsTyVarBndrFlag :: forall flag flag' (pass :: Pass). flag -> HsTyVarBndr flag' (GhcPass pass) -> HsTyVarBndr flag (GhcPass pass) #

Set the attached flag

hsTyVarBndrFlag :: forall flag (pass :: Pass). HsTyVarBndr flag (GhcPass pass) -> flag #

Return the attached flag

updateHsTyVarBndrFlag :: forall flag flag' (pass :: Pass). (flag -> flag') -> HsTyVarBndr flag (GhcPass pass) -> HsTyVarBndr flag' (GhcPass pass) #

Update the attached flag

pprHsType :: forall (p :: Pass). OutputableBndrId p => HsType (GhcPass p) -> SDoc #

pprHsForAll :: forall (p :: Pass). OutputableBndrId p => HsForAllTelescope (GhcPass p) -> Maybe (LHsContext (GhcPass p)) -> SDoc #

Prints a forall; When passed an empty list, prints `forall .`/`forall ->` only when `-dppr-debug` is enabled.

pprHsForAllTelescope :: forall (p :: Pass). OutputableBndrId p => HsForAllTelescope (GhcPass p) -> SDoc #

pprHsOuterFamEqnTyVarBndrs :: forall (p :: Pass). OutputableBndrId p => HsOuterFamEqnTyVarBndrs (GhcPass p) -> SDoc #

Prints the explicit `forall` in a type family equation if one is written. If there is no explicit `forall`, nothing is printed.

pprHsOuterSigTyVarBndrs :: forall (p :: Pass). OutputableBndrId p => HsOuterSigTyVarBndrs (GhcPass p) -> SDoc #

Prints the outermost `forall` in a type signature if one is written. If there is no outermost `forall`, nothing is printed.

pprLHsContext :: forall (p :: Pass). OutputableBndrId p => Maybe (LHsContext (GhcPass p)) -> SDoc #

hsTypeNeedsParens :: forall (p :: Pass). IsPass p => PprPrec -> HsType (GhcPass p) -> Bool #

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

parenthesizeHsType :: forall (p :: Pass). IsPass p => PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

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

parenthesizeHsContext :: forall (p :: Pass). IsPass p => PprPrec -> LHsContext (GhcPass p) -> LHsContext (GhcPass p) #

``parenthesizeHsContext` p ctxt` checks if `ctxt` is a single constraint `c` such that ``hsTypeNeedsParens` p c` is true, and if so, surrounds `c` with an `HsParTy` to form a parenthesized `ctxt`. Otherwise, it simply returns `ctxt` unchanged.

# Orphan instances

Outputable HsIPName # |
Instance details Methods ppr :: HsIPName -> SDoc #
OutputableBndr HsIPName # |
Instance details Methods pprBndr :: BindingSite -> HsIPName -> SDoc # pprPrefixOcc :: HsIPName -> SDoc # pprInfixOcc :: HsIPName -> SDoc # bndrIsJoin_maybe :: HsIPName -> JoinPointHood #
Outputable (XRecGhc (IdGhcP p)) => Outputable (FieldOcc (GhcPass p)) # |
Instance details Methods ppr :: FieldOcc (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsBndrVar (GhcPass p)) # |
Instance details Methods ppr :: HsBndrVar (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsConDeclRecField (GhcPass p)) # |
Instance details Methods ppr :: HsConDeclRecField (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsForAllTelescope (GhcPass p)) # |
Instance details Methods ppr :: HsForAllTelescope (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsPatSigType (GhcPass p)) # |
Instance details Methods ppr :: HsPatSigType (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsSigType (GhcPass p)) # |
Instance details Methods ppr :: HsSigType (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsTyLit (GhcPass p)) # |
Instance details Methods ppr :: HsTyLit (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsTyPat (GhcPass p)) # |
Instance details Methods ppr :: HsTyPat (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsType (GhcPass p)) # |
Instance details Methods ppr :: HsType (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (LHsQTyVars (GhcPass p)) # |
Instance details Methods ppr :: LHsQTyVars (GhcPass p) -> SDoc #
OutputableBndrId pass => OutputableBndr (FieldOcc (GhcPass pass)) # |
Instance details Methods pprBndr :: BindingSite -> FieldOcc (GhcPass pass) -> SDoc # pprPrefixOcc :: FieldOcc (GhcPass pass) -> SDoc # pprInfixOcc :: FieldOcc (GhcPass pass) -> SDoc # bndrIsJoin_maybe :: FieldOcc (GhcPass pass) -> JoinPointHood #
(Outputable arg, Outputable rec) => Outputable (HsConDetails arg rec) # |
Instance details Methods ppr :: HsConDetails arg rec -> SDoc #
(Outputable mult, OutputableBndrId pass) => Outputable (HsMultAnnOf mult (GhcPass pass)) # |
Instance details Methods ppr :: HsMultAnnOf mult (GhcPass pass) -> SDoc #
(OutputableBndrFlag flag p, OutputableBndrFlag flag (NoGhcTcPass p), OutputableBndrId p) => Outputable (HsOuterTyVarBndrs flag (GhcPass p)) # |
Instance details Methods ppr :: HsOuterTyVarBndrs flag (GhcPass p) -> SDoc #
(OutputableBndrId p, OutputableBndrFlag flag p) => Outputable (HsTyVarBndr flag (GhcPass p)) # |
Instance details Methods ppr :: HsTyVarBndr flag (GhcPass p) -> SDoc #
Outputable thing => Outputable (HsWildCardBndrs (GhcPass p) thing) # |
Instance details Methods ppr :: HsWildCardBndrs (GhcPass p) thing -> SDoc #
OutputableBndrId pass => OutputableBndr (GenLocated SrcSpan (FieldOcc (GhcPass pass))) # |
Instance details 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 #
(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 Methods ppr :: HsArg (GhcPass p) tm ty -> SDoc #