Safe Haskell	None
Language	GHC2021

GHC.Hs.Expr

Contents

Orphan instances

Description

Abstract Haskell syntax for expressions.

Synopsis

module Language.Haskell.Syntax.Expr
gHsPar :: forall (p :: Pass). IsPass p => LHsExpr (GhcPass p) -> HsExpr (GhcPass p)
hsExprNeedsParens :: forall (p :: Pass). IsPass p => PprPrec -> HsExpr (GhcPass p) -> Bool
hsLMatchPats :: forall (id :: Pass) body. LMatch (GhcPass id) body -> [LPat (GhcPass id)]
isAtomicHsExpr :: forall (p :: Pass). IsPass p => HsExpr (GhcPass p) -> Bool
isEmptyMatchGroup :: forall (p :: Pass) body. MatchGroup (GhcPass p) body -> Bool
isHsThingRnExpr :: HsThingRn -> Bool
isHsThingRnPat :: HsThingRn -> Bool
isHsThingRnStmt :: HsThingRn -> Bool
isInfixMatch :: forall (p :: Pass) body. Match (GhcPass p) body -> Bool
isQuietHsCmd :: HsCmd id -> Bool
isQuietHsExpr :: HsExpr id -> Bool
isSingletonMatchGroup :: forall (p :: Pass) body. [LMatch (GhcPass p) body] -> Bool
lamCaseKeyword :: HsLamVariant -> SDoc
matchArrowContextErrString :: HsArrowMatchContext -> SDoc
matchContextErrString :: Outputable fn => HsMatchContext fn -> SDoc
matchDoContextErrString :: HsDoFlavour -> SDoc
matchGroupArity :: forall (id :: Pass) body. MatchGroup (GhcPass id) body -> Arity
matchSeparator :: HsMatchContext fn -> SDoc
mkExpandedExpr :: HsExpr GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
mkExpandedExprTc :: HsExpr GhcRn -> HsExpr GhcTc -> HsExpr GhcTc
mkExpandedPatRn :: LPat GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
mkExpandedStmt :: ExprLStmt GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
mkExpandedStmtAt :: SrcSpanAnnA -> ExprLStmt GhcRn -> HsExpr GhcRn -> LHsExpr GhcRn
mkExpandedStmtPopAt :: SrcSpanAnnA -> ExprLStmt GhcRn -> HsExpr GhcRn -> LHsExpr GhcRn
mkExpandedStmtTc :: ExprLStmt GhcRn -> HsExpr GhcTc -> HsExpr GhcTc
mkHsVar :: forall (p :: Pass). IsPass p => LIdP (GhcPass p) -> HsExpr (GhcPass p)
mkHsVarWithUserRdr :: forall (p :: Pass). IsPass p => RdrName -> LIdP (GhcPass p) -> HsExpr (GhcPass p)
mkPopErrCtxtExpr :: LHsExpr GhcRn -> HsExpr GhcRn
mkPopErrCtxtExprAt :: SrcSpanAnnA -> LHsExpr GhcRn -> LHsExpr GhcRn
mkSyntaxExpr :: HsExpr GhcRn -> SyntaxExprRn
multAnnToHsExpr :: HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> Maybe (LocatedA (HsExpr GhcRn))
noExpr :: forall (p :: Pass). HsExpr (GhcPass p)
noSyntaxExpr :: forall (p :: Pass). IsPass p => SyntaxExpr (GhcPass p)
parenthesizeHsExpr :: forall (p :: Pass). IsPass p => PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
pp_dotdot :: SDoc
pp_rhs :: Outputable body => HsMatchContext fn -> body -> SDoc
pprAHsDoFlavour :: HsDoFlavour -> SDoc
pprAStmtContext :: Outputable fn => HsStmtContext fn -> SDoc
pprArg :: forall (idL :: Pass). OutputableBndrId idL => ApplicativeArg (GhcPass idL) -> SDoc
pprArrowExpr :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc
pprArrowMatchContextNoun :: HsArrowMatchContext -> SDoc
pprArrowMatchContextNouns :: HsArrowMatchContext -> SDoc
pprBindStmt :: (Outputable pat, Outputable expr) => pat -> expr -> SDoc
pprBinds :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
pprBy :: Outputable body => Maybe body -> SDoc
pprCmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc
pprCmdArg :: forall (p :: Pass). OutputableBndrId p => HsCmdTop (GhcPass p) -> SDoc
pprComp :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc
pprDebugParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprDo :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => HsDoFlavour -> [LStmt (GhcPass p) body] -> SDoc
pprExpr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc
pprExternalSrcLoc :: (StringLiteral, (Int, Int), (Int, Int)) -> SDoc
pprFieldLabelStrings :: (UnXRec p, Outputable (XRec p FieldLabelString)) => FieldLabelStrings p -> SDoc
pprFunBind :: forall (idR :: Pass). OutputableBndrId idR => MatchGroup (GhcPass idR) (LHsExpr (GhcPass idR)) -> SDoc
pprGRHS :: forall (idR :: Pass) body fn. (OutputableBndrId idR, Outputable body) => HsMatchContext fn -> GRHS (GhcPass idR) body -> SDoc
pprGRHSs :: forall (idR :: Pass) body fn. (OutputableBndrId idR, Outputable body) => HsMatchContext fn -> GRHSs (GhcPass idR) body -> SDoc
pprHsArrType :: HsArrAppType -> SDoc
pprHsDoFlavour :: HsDoFlavour -> SDoc
pprLCmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc
pprLExpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc
pprMatch :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc
pprMatchContext :: Outputable p => HsMatchContext p -> SDoc
pprMatchContextNoun :: Outputable fn => HsMatchContext fn -> SDoc
pprMatchContextNouns :: Outputable fn => HsMatchContext fn -> SDoc
pprMatchInCtxt :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc
pprMatches :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => MatchGroup (GhcPass idR) body -> SDoc
pprParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> HsExpr (GhcPass p) -> SDoc
pprParendLExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprPatBind :: forall (bndr :: Pass) (p :: Pass). (OutputableBndrId bndr, OutputableBndrId p) => LPat (GhcPass bndr) -> GRHSs (GhcPass p) (LHsExpr (GhcPass p)) -> SDoc
pprPrefixFastString :: FastString -> SDoc
pprQuals :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc
pprStmt :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA, Outputable body) => StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
pprStmtCat :: forall (p :: Pass) body. IsPass p => Stmt (GhcPass p) body -> SDoc
pprStmtContext :: Outputable fn => HsStmtContext fn -> SDoc
pprStmtInCtxt :: forall (idL :: Pass) (idR :: Pass) fn body. (OutputableBndrId idL, OutputableBndrId idR, Outputable fn, Outputable body, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA) => HsStmtContext fn -> StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
pprTransStmt :: Outputable body => Maybe body -> body -> TransForm -> SDoc
pprTransformStmt :: forall (p :: Pass). OutputableBndrId p => [IdP (GhcPass p)] -> LHsExpr (GhcPass p) -> Maybe (LHsExpr (GhcPass p)) -> SDoc
pprTypedSplice :: forall (p :: Pass). OutputableBndrId p => Maybe SplicePointName -> HsTypedSplice (GhcPass p) -> SDoc
pprUntypedSplice :: forall (p :: Pass). OutputableBndrId p => Bool -> Maybe SplicePointName -> HsUntypedSplice (GhcPass p) -> SDoc
ppr_apps :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))] -> SDoc
ppr_cmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc
ppr_do_stmts :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA, Outputable body) => [LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc
ppr_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc
ppr_infix_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> Maybe SDoc
ppr_infix_expr_rn :: XXExprGhcRn -> Maybe SDoc
ppr_infix_expr_tc :: XXExprGhcTc -> Maybe SDoc
ppr_infix_hs_expansion :: HsThingRn -> Maybe SDoc
ppr_lcmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc
ppr_lexpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc
ppr_module_name_prefix :: Maybe ModuleName -> SDoc
ppr_quasi :: OutputableBndr p => p -> FastString -> SDoc
ppr_splice :: forall (p :: Pass). OutputableBndrId p => SDoc -> Maybe SplicePointName -> LHsExpr (GhcPass p) -> SDoc
ppr_with_pending_tc_splices :: SDoc -> [PendingTcSplice] -> SDoc
prependQualified :: Maybe ModuleName -> SDoc -> SDoc
stripParensHsExpr :: forall (p :: Pass). HsExpr (GhcPass p) -> HsExpr (GhcPass p)
stripParensLHsExpr :: forall (p :: Pass). LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
thBrackets :: SDoc -> SDoc -> SDoc
thTyBrackets :: SDoc -> SDoc
tupArgPresent :: forall (p :: Pass). HsTupArg (GhcPass p) -> Bool
tupArgPresent_maybe :: forall (p :: Pass). HsTupArg (GhcPass p) -> Maybe (LHsExpr (GhcPass p))
tupArgsPresent_maybe :: forall (p :: Pass). [HsTupArg (GhcPass p)] -> Maybe [LHsExpr (GhcPass p)]
unnamedHoleRdrName :: RdrName
data AnnArithSeq = AnnArithSeq {
- aas_open :: EpToken "["
- aas_comma :: Maybe (EpToken ",")
- aas_dotdot :: EpToken ".."
- aas_close :: EpToken "]"
}
data AnnExplicitSum = AnnExplicitSum {
- aesOpen :: EpaLocation
- aesBarsBefore :: [EpToken "|"]
- aesBarsAfter :: [EpToken "|"]
- aesClose :: EpaLocation
}
data AnnFieldLabel = AnnFieldLabel {
- afDot :: Maybe (EpToken ".")
}
data AnnFunRhs = AnnFunRhs {
- afr_strict :: EpToken "!"
- afr_opens :: [EpToken "("]
- afr_closes :: [EpToken ")"]
}
data AnnProjection = AnnProjection {
- apOpen :: EpToken "("
- apClose :: EpToken ")"
}
data AnnTransStmt = AnnTransStmt {
- ats_then :: EpToken "then"
- ats_group :: Maybe (EpToken "group")
- ats_by :: Maybe (EpToken "by")
- ats_using :: Maybe (EpToken "using")
}
data AnnsIf = AnnsIf {
- aiIf :: EpToken "if"
- aiThen :: EpToken "then"
- aiElse :: EpToken "else"
- aiThenSemi :: Maybe (EpToken ";")
- aiElseSemi :: Maybe (EpToken ";")
}
data ApplicativeArg idL
- = ApplicativeArgOne {
  - xarg_app_arg_one :: XApplicativeArgOne idL
  - app_arg_pattern :: LPat idL
  - arg_expr :: LHsExpr idL
  - is_body_stmt :: Bool
  }
- | ApplicativeArgMany {
  - xarg_app_arg_many :: XApplicativeArgMany idL
  - app_stmts :: [ExprLStmt idL]
  - final_expr :: HsExpr idL
  - bv_pattern :: LPat idL
  - stmt_context :: HsDoFlavour
  }
- | XApplicativeArg !(XXApplicativeArg idL)
data ApplicativeStmt idL idR = ApplicativeStmt (XApplicativeStmt idL idR) [(SyntaxExpr idR, ApplicativeArg idL)] (Maybe (SyntaxExpr idR))
data BracketAnn noE hasE
- = BracketNoE noE
- | BracketHasE hasE
type CmdSyntaxTable p = [(Name, HsExpr p)]
data CmdTopTc = CmdTopTc Type Type (CmdSyntaxTable GhcTc)
data DelayedSplice = DelayedSplice TcLclEnv (LHsExpr GhcRn) TcType (LHsExpr GhcTc)
data EpAnnHsCase = EpAnnHsCase {
- hsCaseAnnCase :: EpToken "case"
- hsCaseAnnOf :: EpToken "of"
}
data EpAnnLam = EpAnnLam {
- epl_lambda :: EpToken "\\"
- epl_case :: Maybe EpaLocation
}
data GrhsAnn = GrhsAnn {
- ga_vbar :: Maybe (EpToken "|")
- ga_sep :: Either (EpToken "=") TokRarrow
}
data HoleKind
- = HoleVar (LIdP GhcPs)
- | HoleError
data HsBracketTc = HsBracketTc {
- hsb_quote :: HsQuote GhcRn
- hsb_ty :: Type
- hsb_wrap :: Maybe QuoteWrapper
- hsb_splices :: [PendingTcSplice]
}
data HsImplicitLiftSplice = HsImplicitLiftSplice {
- implicit_lift_bind_lvl :: Set ThLevelIndex
- implicit_lift_used_lvl :: ThLevelIndex
- implicit_lift_gre :: Maybe GlobalRdrElt
- implicit_lift_lid :: LIdOccP GhcRn
}
type HsMatchContextPs = HsMatchContext (LIdP GhcPs)
type HsMatchContextRn = HsMatchContext (LIdP GhcRn)
data HsQuasiQuoteExt = HsQuasiQuoteExt {
- quasi_quote_flavour :: UntypedSpliceFlavour
}
data family HsRecUpdParent x
type HsStmtContextRn = HsStmtContext (LIdP GhcRn)
data HsThingRn
- = OrigExpr (HsExpr GhcRn)
- | OrigStmt (ExprLStmt GhcRn)
- | OrigPat (LPat GhcRn)
data HsTypedSpliceResult
- = HsTypedSpliceTop
- | HsTypedSpliceNested SplicePointName
data HsUntypedSpliceResult thing
- = HsUntypedSpliceTop {
  - utsplice_result_finalizers :: ThModFinalizers
  - utsplice_result :: thing
  }
- | HsUntypedSpliceNested SplicePointName
data HsUserSpliceExt = HsUserSpliceExt {
- user_splice_flavour :: UntypedSpliceFlavour
}
data HsWrap (hs_syn :: Type -> Type) = HsWrap HsWrapper (hs_syn GhcTc)
data MatchGroupTc = MatchGroupTc {
- mg_arg_tys :: [Scaled Type]
- mg_res_ty :: Type
- mg_origin :: Origin
}
data PendingRnSplice = PendingRnSplice SplicePointName (HsUntypedSplice GhcRn)
data PendingTcSplice = PendingTcSplice SplicePointName (LHsExpr GhcTc)
type PostTcExpr = HsExpr GhcTc
type PostTcTable = [(Name, PostTcExpr)]
data RecStmtTc = RecStmtTc {
- recS_bind_ty :: Type
- recS_later_rets :: [PostTcExpr]
- recS_rec_rets :: [PostTcExpr]
- recS_ret_ty :: Type
}
type SplicePointName = Name
type family SyntaxExprGhc (p :: Pass) = (r :: Type) | r -> p where ...
data SyntaxExprRn
- = SyntaxExprRn (HsExpr GhcRn)
- | NoSyntaxExprRn
data SyntaxExprTc
- = SyntaxExprTc {
  - syn_expr :: HsExpr GhcTc
  - syn_arg_wraps :: [HsWrapper]
  - syn_res_wrap :: HsWrapper
  }
- | NoSyntaxExprTc
newtype ThModFinalizers = ThModFinalizers [ForeignRef (Q ())]
data UntypedSpliceFlavour
- = UntypedExpSplice
- | UntypedPatSplice
- | UntypedTypeSplice
- | UntypedDeclSplice
type family XApplicativeArgMany x
type family XApplicativeArgOne x
type family XApplicativeStmt x x'
data XBindStmtRn = XBindStmtRn {
- xbsrn_bindOp :: SyntaxExpr GhcRn
- xbsrn_failOp :: FailOperator GhcRn
}
data XBindStmtTc = XBindStmtTc {
- xbstc_bindOp :: SyntaxExpr GhcTc
- xbstc_boundResultType :: Type
- xbstc_boundResultMult :: Mult
- xbstc_failOp :: FailOperator GhcTc
}
type family XXApplicativeArg x
data XXExprGhcRn
- = ExpandedThingRn {
  - xrn_orig :: HsThingRn
  - xrn_expanded :: HsExpr GhcRn
  }
- | PopErrCtxt !(LHsExpr GhcRn)
- | HsRecSelRn (FieldOcc GhcRn)
data XXExprGhcTc
- = WrapExpr HsWrapper (HsExpr GhcTc)
- | ExpandedThingTc {
  - xtc_orig :: HsThingRn
  - xtc_expanded :: HsExpr GhcTc
  }
- | ConLikeTc ConLike [TcTyVar] [Scaled TcType]
- | HsTick CoreTickish (LHsExpr GhcTc)
- | HsBinTick Int Int (LHsExpr GhcTc)
- | HsRecSelTc (FieldOcc GhcTc)

Documentation

module Language.Haskell.Syntax.Expr

gHsPar :: forall (p :: Pass). IsPass p => LHsExpr (GhcPass p) -> HsExpr (GhcPass p) #

Parenthesize an expression without token information

hsExprNeedsParens :: forall (p :: Pass). IsPass p => PprPrec -> HsExpr (GhcPass p) -> Bool #

hsExprNeedsParens p e returns True if the expression e needs parentheses under precedence p.

hsLMatchPats :: forall (id :: Pass) body. LMatch (GhcPass id) body -> [LPat (GhcPass id)] #

isAtomicHsExpr :: forall (p :: Pass). IsPass p => HsExpr (GhcPass p) -> Bool #

isEmptyMatchGroup :: forall (p :: Pass) body. MatchGroup (GhcPass p) body -> Bool #

isHsThingRnExpr :: HsThingRn -> Bool #

isHsThingRnPat :: HsThingRn -> Bool #

isHsThingRnStmt :: HsThingRn -> Bool #

isInfixMatch :: forall (p :: Pass) body. Match (GhcPass p) body -> Bool #

isQuietHsCmd :: HsCmd id -> Bool #

isQuietHsExpr :: HsExpr id -> Bool #

isSingletonMatchGroup :: forall (p :: Pass) body. [LMatch (GhcPass p) body] -> Bool #

Is there only one RHS in this list of matches?

lamCaseKeyword :: HsLamVariant -> SDoc #

matchArrowContextErrString :: HsArrowMatchContext -> SDoc #

matchContextErrString :: Outputable fn => HsMatchContext fn -> SDoc #

matchDoContextErrString :: HsDoFlavour -> SDoc #

matchGroupArity :: forall (id :: Pass) body. MatchGroup (GhcPass id) body -> Arity #

matchSeparator :: HsMatchContext fn -> SDoc #

mkExpandedExpr #

Arguments

:: HsExpr GhcRn	source expression
-> HsExpr GhcRn	expanded expression
-> HsExpr GhcRn	suitably wrapped `XXExprGhcRn`

Build an expression using the extension constructor XExpr, and the two components of the expansion: original expression and expanded expressions.

mkExpandedExprTc #

Arguments

:: HsExpr GhcRn	source expression
-> HsExpr GhcTc	expanded typechecked expression
-> HsExpr GhcTc	suitably wrapped `XXExprGhcRn`

Build a XXExprGhcRn out of an extension constructor, and the two components of the expansion: original and expanded typechecked expressions.

mkExpandedPatRn #

Arguments

:: LPat GhcRn	source pattern
-> HsExpr GhcRn	expanded expression
-> HsExpr GhcRn	suitably wrapped `XXExprGhcRn`

mkExpandedStmt #

Arguments

:: ExprLStmt GhcRn	source statement
-> HsExpr GhcRn	expanded expression
-> HsExpr GhcRn	suitably wrapped `XXExprGhcRn`

Build an expression using the extension constructor XExpr, and the two components of the expansion: original do stmt and expanded expression

mkExpandedStmtAt #

Arguments

:: SrcSpanAnnA	Location for the expansion expression
-> ExprLStmt GhcRn	source statement
-> HsExpr GhcRn	expanded expression
-> LHsExpr GhcRn	suitably wrapped located `XXExprGhcRn`

Build an expression using the extension constructor XExpr, and the two components of the expansion: original do stmt and expanded expression an associate with a provided location

mkExpandedStmtPopAt #

Arguments

:: SrcSpanAnnA	Location for the expansion statement
-> ExprLStmt GhcRn	source statement
-> HsExpr GhcRn	expanded expression
-> LHsExpr GhcRn	suitably wrapped `XXExprGhcRn`

Wrap the expanded version of the expression with a pop.

mkExpandedStmtTc #

Arguments

:: ExprLStmt GhcRn	source do statement
-> HsExpr GhcTc	expanded typechecked expression
-> HsExpr GhcTc	suitably wrapped `XXExprGhcRn`

Build a XXExprGhcRn out of an extension constructor. The two components of the expansion are: original statement and expanded typechecked expression.

mkHsVar :: forall (p :: Pass). IsPass p => LIdP (GhcPass p) -> HsExpr (GhcPass p) #

mkHsVarWithUserRdr :: forall (p :: Pass). IsPass p => RdrName -> LIdP (GhcPass p) -> HsExpr (GhcPass p) #

mkPopErrCtxtExpr :: LHsExpr GhcRn -> HsExpr GhcRn #

Wrap a located expression with a PopErrCtxt

mkPopErrCtxtExprAt :: SrcSpanAnnA -> LHsExpr GhcRn -> LHsExpr GhcRn #

Wrap a located expression with a PopSrcExpr with an appropriate location

mkSyntaxExpr :: HsExpr GhcRn -> SyntaxExprRn #

Make a 'SyntaxExpr GhcRn' from an expression Used only in getMonadFailOp. See Note [Monad fail : Rebindable syntax, overloaded strings] in GHC.Rename.Expr

multAnnToHsExpr :: HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> Maybe (LocatedA (HsExpr GhcRn)) #

noExpr :: forall (p :: Pass). HsExpr (GhcPass p) #

This is used for rebindable-syntax pieces that are too polymorphic for tcSyntaxOp (trS_fmap and the mzip in ParStmt)

noSyntaxExpr :: forall (p :: Pass). IsPass p => SyntaxExpr (GhcPass p) #

parenthesizeHsExpr :: forall (p :: Pass). IsPass p => PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) #

parenthesizeHsExpr p e checks if hsExprNeedsParens p e is true, and if so, surrounds e with an HsPar. Otherwise, it simply returns e.

pp_dotdot :: SDoc #

pp_rhs :: Outputable body => HsMatchContext fn -> body -> SDoc #

pprAHsDoFlavour :: HsDoFlavour -> SDoc #

pprAStmtContext :: Outputable fn => HsStmtContext fn -> SDoc #

pprArg :: forall (idL :: Pass). OutputableBndrId idL => ApplicativeArg (GhcPass idL) -> SDoc #

pprArrowExpr :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc #

pprArrowMatchContextNoun :: HsArrowMatchContext -> SDoc #

pprArrowMatchContextNouns :: HsArrowMatchContext -> SDoc #

pprBindStmt :: (Outputable pat, Outputable expr) => pat -> expr -> SDoc #

pprBinds :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc #

pprBy :: Outputable body => Maybe body -> SDoc #

pprCmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc #

pprCmdArg :: forall (p :: Pass). OutputableBndrId p => HsCmdTop (GhcPass p) -> SDoc #

pprComp :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc #

pprDebugParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc #

pprDo :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => HsDoFlavour -> [LStmt (GhcPass p) body] -> SDoc #

pprExpr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc #

pprExternalSrcLoc :: (StringLiteral, (Int, Int), (Int, Int)) -> SDoc #

pprFieldLabelStrings :: (UnXRec p, Outputable (XRec p FieldLabelString)) => FieldLabelStrings p -> SDoc #

pprFunBind :: forall (idR :: Pass). OutputableBndrId idR => MatchGroup (GhcPass idR) (LHsExpr (GhcPass idR)) -> SDoc #

pprGRHS :: forall (idR :: Pass) body fn. (OutputableBndrId idR, Outputable body) => HsMatchContext fn -> GRHS (GhcPass idR) body -> SDoc #

pprGRHSs :: forall (idR :: Pass) body fn. (OutputableBndrId idR, Outputable body) => HsMatchContext fn -> GRHSs (GhcPass idR) body -> SDoc #

pprHsArrType :: HsArrAppType -> SDoc #

pprHsDoFlavour :: HsDoFlavour -> SDoc #

pprLCmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc #

pprLExpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc #

pprMatch :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc #

pprMatchContext :: Outputable p => HsMatchContext p -> SDoc #

pprMatchContextNoun :: Outputable fn => HsMatchContext fn -> SDoc #

pprMatchContextNouns :: Outputable fn => HsMatchContext fn -> SDoc #

pprMatchInCtxt :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc #

pprMatches :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => MatchGroup (GhcPass idR) body -> SDoc #

pprParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> HsExpr (GhcPass p) -> SDoc #

pprParendLExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc #

pprPatBind :: forall (bndr :: Pass) (p :: Pass). (OutputableBndrId bndr, OutputableBndrId p) => LPat (GhcPass bndr) -> GRHSs (GhcPass p) (LHsExpr (GhcPass p)) -> SDoc #

pprPrefixFastString :: FastString -> SDoc #

pprQuals :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc #

pprStmt :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA, Outputable body) => StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc #

pprStmtCat :: forall (p :: Pass) body. IsPass p => Stmt (GhcPass p) body -> SDoc #

pprStmtContext :: Outputable fn => HsStmtContext fn -> SDoc #

pprStmtInCtxt :: forall (idL :: Pass) (idR :: Pass) fn body. (OutputableBndrId idL, OutputableBndrId idR, Outputable fn, Outputable body, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA) => HsStmtContext fn -> StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc #

pprTransStmt :: Outputable body => Maybe body -> body -> TransForm -> SDoc #

pprTransformStmt :: forall (p :: Pass). OutputableBndrId p => [IdP (GhcPass p)] -> LHsExpr (GhcPass p) -> Maybe (LHsExpr (GhcPass p)) -> SDoc #

pprTypedSplice :: forall (p :: Pass). OutputableBndrId p => Maybe SplicePointName -> HsTypedSplice (GhcPass p) -> SDoc #

pprUntypedSplice :: forall (p :: Pass). OutputableBndrId p => Bool -> Maybe SplicePointName -> HsUntypedSplice (GhcPass p) -> SDoc #

ppr_apps :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))] -> SDoc #

ppr_cmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc #

ppr_do_stmts :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA, Outputable body) => [LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc #

ppr_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc #

ppr_infix_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> Maybe SDoc #

ppr_infix_expr_rn :: XXExprGhcRn -> Maybe SDoc #

ppr_infix_expr_tc :: XXExprGhcTc -> Maybe SDoc #

ppr_infix_hs_expansion :: HsThingRn -> Maybe SDoc #

ppr_lcmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc #

ppr_lexpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc #

ppr_module_name_prefix :: Maybe ModuleName -> SDoc #

ppr_quasi :: OutputableBndr p => p -> FastString -> SDoc #

ppr_splice :: forall (p :: Pass). OutputableBndrId p => SDoc -> Maybe SplicePointName -> LHsExpr (GhcPass p) -> SDoc #

ppr_with_pending_tc_splices :: SDoc -> [PendingTcSplice] -> SDoc #

prependQualified :: Maybe ModuleName -> SDoc -> SDoc #

stripParensHsExpr :: forall (p :: Pass). HsExpr (GhcPass p) -> HsExpr (GhcPass p) #

stripParensLHsExpr :: forall (p :: Pass). LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) #

thBrackets :: SDoc -> SDoc -> SDoc #

thTyBrackets :: SDoc -> SDoc #

tupArgPresent :: forall (p :: Pass). HsTupArg (GhcPass p) -> Bool #

tupArgPresent_maybe :: forall (p :: Pass). HsTupArg (GhcPass p) -> Maybe (LHsExpr (GhcPass p)) #

tupArgsPresent_maybe :: forall (p :: Pass). [HsTupArg (GhcPass p)] -> Maybe [LHsExpr (GhcPass p)] #

unnamedHoleRdrName :: RdrName #

The RdrName for an unnamed hole ("_").

data AnnArithSeq #

Constructors

AnnArithSeq
Fields aas_open :: EpToken "[" aas_comma :: Maybe (EpToken ",") aas_dotdot :: EpToken ".." aas_close :: EpToken "]"

Instances

Instances details

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

data AnnExplicitSum #

Constructors

AnnExplicitSum
Fields aesOpen :: EpaLocation aesBarsBefore :: [EpToken "\|"] aesBarsAfter :: [EpToken "\|"] aesClose :: EpaLocation

Instances

Instances details

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

data AnnFieldLabel #

Constructors

AnnFieldLabel
Fields afDot :: Maybe (EpToken ".")

Instances

Instances details

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

data AnnFunRhs #

Constructors

AnnFunRhs
Fields afr_strict :: EpToken "!" afr_opens :: [EpToken "("] afr_closes :: [EpToken ")"]

Instances

Instances details

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

data AnnProjection #

Constructors

AnnProjection
Fields apOpen :: EpToken "(" apClose :: EpToken ")"

Instances

Instances details

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

data AnnTransStmt #

Constructors

AnnTransStmt
Fields ats_then :: EpToken "then" ats_group :: Maybe (EpToken "group") ats_by :: Maybe (EpToken "by") ats_using :: Maybe (EpToken "using")

Instances

Instances details

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

data AnnsIf #

Constructors

AnnsIf
Fields aiIf :: EpToken "if" aiThen :: EpToken "then" aiElse :: EpToken "else" aiThenSemi :: Maybe (EpToken ";") aiElseSemi :: Maybe (EpToken ";")

Instances

Instances details

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

data ApplicativeArg idL #

Applicative Argument

Constructors

ApplicativeArgOne
Fields xarg_app_arg_one :: XApplicativeArgOne idL The fail operator, after renaming The fail operator is needed if this is a BindStmt where the pattern can fail. E.g.: (Just a) <- stmt The fail operator will be invoked if the pattern match fails. It is also used for guards in MonadComprehensions. The fail operator is Nothing if the pattern match can't fail app_arg_pattern :: LPat idL arg_expr :: LHsExpr idL is_body_stmt :: Bool True = was a BodyStmt, False = was a BindStmt. See Note [Applicative BodyStmt]
ApplicativeArgMany
Fields xarg_app_arg_many :: XApplicativeArgMany idL app_stmts :: [ExprLStmt idL] final_expr :: HsExpr idL bv_pattern :: LPat idL stmt_context :: HsDoFlavour context of the do expression, used in pprArg
XApplicativeArg !(XXApplicativeArg idL)

Instances

Instances details

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

data ApplicativeStmt idL idR #

ApplicativeStmt represents an applicative expression built with <$> and <*>. It is generated by the renamer, and is desugared into the appropriate applicative expression by the desugarer, but it is intended to be invisible in error messages.

For full details, see Note [ApplicativeDo] in GHC.Rename.Expr

Constructors

ApplicativeStmt (XApplicativeStmt idL idR) [(SyntaxExpr idR, ApplicativeArg idL)] (Maybe (SyntaxExpr idR))

Instances

Instances details

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

data BracketAnn noE hasE #

Constructors

BracketNoE noE
BracketHasE hasE

Instances

Instances details

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

type CmdSyntaxTable p = [(Name, HsExpr p)] #

Command Syntax Table (for Arrow syntax)

data CmdTopTc #

Constructors

CmdTopTc Type Type (CmdSyntaxTable GhcTc)

Instances

Instances details

Data CmdTopTc #

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) -> CmdTopTc -> c CmdTopTc Source #

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

toConstr :: CmdTopTc -> Constr Source #

dataTypeOf :: CmdTopTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data DelayedSplice #

Constructors

DelayedSplice TcLclEnv (LHsExpr GhcRn) TcType (LHsExpr GhcTc)

Instances

Instances details

Data DelayedSplice #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: DelayedSplice -> Constr Source #

dataTypeOf :: DelayedSplice -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data EpAnnHsCase #

Constructors

EpAnnHsCase
Fields hsCaseAnnCase :: EpToken "case" hsCaseAnnOf :: EpToken "of"

Instances

Instances details

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

data EpAnnLam #

Constructors

EpAnnLam
Fields epl_lambda :: EpToken "\\" Location of '\' keyword epl_case :: Maybe EpaLocation Location of 'case' or `cases` keyword, depending on related `HsLamVariant`.

Instances

Instances details

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

data GrhsAnn #

Constructors

GrhsAnn
Fields ga_vbar :: Maybe (EpToken "\|") ga_sep :: Either (EpToken "=") TokRarrow Match separator location, `=` or `->`

Instances

Instances details

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

data HoleKind #

Constructors

HoleVar (LIdP GhcPs)
HoleError

Instances

Instances details

Data HoleKind #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: HoleKind -> Constr Source #

dataTypeOf :: HoleKind -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data HsBracketTc #

Constructors

HsBracketTc
Fields hsb_quote :: HsQuote GhcRn hsb_ty :: Type hsb_wrap :: Maybe QuoteWrapper hsb_splices :: [PendingTcSplice]

Instances

Instances details

Data HsBracketTc #

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) -> HsBracketTc -> c HsBracketTc Source #

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

toConstr :: HsBracketTc -> Constr Source #

dataTypeOf :: HsBracketTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data HsImplicitLiftSplice #

Information about an implicit lift, discovered by the renamer See Note [Lifecycle of an untyped splice, and PendingRnSplice]

Constructors

HsImplicitLiftSplice
Fields implicit_lift_bind_lvl :: Set ThLevelIndex implicit_lift_used_lvl :: ThLevelIndex implicit_lift_gre :: Maybe GlobalRdrElt implicit_lift_lid :: LIdOccP GhcRn

Instances

Instances details

Data HsImplicitLiftSplice #

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) -> HsImplicitLiftSplice -> c HsImplicitLiftSplice Source #

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

toConstr :: HsImplicitLiftSplice -> Constr Source #

dataTypeOf :: HsImplicitLiftSplice -> DataType Source #

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

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

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

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

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

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

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

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

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

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

type HsMatchContextPs = HsMatchContext (LIdP GhcPs) #

type HsMatchContextRn = HsMatchContext (LIdP GhcRn) #

data HsQuasiQuoteExt #

Information about a quasi-quoter, discovered by the renamer See Note [Lifecycle of an untyped splice, and PendingRnSplice]

Constructors

HsQuasiQuoteExt
Fields quasi_quote_flavour :: UntypedSpliceFlavour

Instances

Instances details

Data HsQuasiQuoteExt #

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) -> HsQuasiQuoteExt -> c HsQuasiQuoteExt Source #

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

toConstr :: HsQuasiQuoteExt -> Constr Source #

dataTypeOf :: HsQuasiQuoteExt -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data family HsRecUpdParent x #

Information about the parent of a record update:

the parent type constructor or pattern synonym,
the relevant con-likes,
the field labels.

Instances

Instances details

Data (HsRecUpdParent 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) -> HsRecUpdParent GhcPs -> c (HsRecUpdParent GhcPs) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsRecUpdParent GhcPs) Source # toConstr :: HsRecUpdParent GhcPs -> Constr Source # dataTypeOf :: HsRecUpdParent GhcPs -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsRecUpdParent GhcPs)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsRecUpdParent GhcPs)) Source # gmapT :: (forall b. Data b => b -> b) -> HsRecUpdParent GhcPs -> HsRecUpdParent GhcPs Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRecUpdParent GhcPs -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRecUpdParent GhcPs -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsRecUpdParent GhcPs -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRecUpdParent GhcPs -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRecUpdParent GhcPs -> m (HsRecUpdParent GhcPs) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecUpdParent GhcPs -> m (HsRecUpdParent GhcPs) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecUpdParent GhcPs -> m (HsRecUpdParent GhcPs) Source #
Data (HsRecUpdParent 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) -> HsRecUpdParent GhcRn -> c (HsRecUpdParent GhcRn) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsRecUpdParent GhcRn) Source # toConstr :: HsRecUpdParent GhcRn -> Constr Source # dataTypeOf :: HsRecUpdParent GhcRn -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsRecUpdParent GhcRn)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsRecUpdParent GhcRn)) Source # gmapT :: (forall b. Data b => b -> b) -> HsRecUpdParent GhcRn -> HsRecUpdParent GhcRn Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRecUpdParent GhcRn -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRecUpdParent GhcRn -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsRecUpdParent GhcRn -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRecUpdParent GhcRn -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRecUpdParent GhcRn -> m (HsRecUpdParent GhcRn) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecUpdParent GhcRn -> m (HsRecUpdParent GhcRn) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecUpdParent GhcRn -> m (HsRecUpdParent GhcRn) Source #
Data (HsRecUpdParent 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) -> HsRecUpdParent GhcTc -> c (HsRecUpdParent GhcTc) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsRecUpdParent GhcTc) Source # toConstr :: HsRecUpdParent GhcTc -> Constr Source # dataTypeOf :: HsRecUpdParent GhcTc -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsRecUpdParent GhcTc)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsRecUpdParent GhcTc)) Source # gmapT :: (forall b. Data b => b -> b) -> HsRecUpdParent GhcTc -> HsRecUpdParent GhcTc Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRecUpdParent GhcTc -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRecUpdParent GhcTc -> r Source # gmapQ :: (forall d. Data d => d -> u) -> HsRecUpdParent GhcTc -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRecUpdParent GhcTc -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRecUpdParent GhcTc -> m (HsRecUpdParent GhcTc) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecUpdParent GhcTc -> m (HsRecUpdParent GhcTc) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecUpdParent GhcTc -> m (HsRecUpdParent GhcTc) Source #
data HsRecUpdParent GhcPs #
Instance details Defined in GHC.Hs.Expr data HsRecUpdParent GhcPs
data HsRecUpdParent GhcRn #
Instance details Defined in GHC.Hs.Expr data HsRecUpdParent GhcRn = RnRecUpdParent { rnRecUpdLabels :: NonEmpty FieldGlobalRdrElt rnRecUpdCons :: UniqSet ConLikeName }
data HsRecUpdParent GhcTc #
Instance details Defined in GHC.Hs.Expr data HsRecUpdParent GhcTc = TcRecUpdParent { tcRecUpdParent :: RecSelParent tcRecUpdLabels :: NonEmpty FieldGlobalRdrElt tcRecUpdCons :: UniqSet ConLike }

type HsStmtContextRn = HsStmtContext (LIdP GhcRn) #

data HsThingRn #

The different source constructs that we use to instantiate the "original" field in an `XXExprGhcRn original expansion`

Constructors

OrigExpr (HsExpr GhcRn)
OrigStmt (ExprLStmt GhcRn)
OrigPat (LPat GhcRn)

Instances

Instances details

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

data HsTypedSpliceResult #

Constructors

HsTypedSpliceTop
HsTypedSpliceNested SplicePointName

Instances

Instances details

Data HsTypedSpliceResult #

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) -> HsTypedSpliceResult -> c HsTypedSpliceResult Source #

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

toConstr :: HsTypedSpliceResult -> Constr Source #

dataTypeOf :: HsTypedSpliceResult -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data HsUntypedSpliceResult thing #

Constructors

HsUntypedSpliceTop
Fields utsplice_result_finalizers :: ThModFinalizers TH finalizers produced by the splice. utsplice_result :: thing The result of splicing; See Note [Lifecycle of a splice]
HsUntypedSpliceNested SplicePointName

Instances

Instances details

Data a => Data (HsUntypedSpliceResult a) #

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) -> HsUntypedSpliceResult a -> c (HsUntypedSpliceResult a) Source #

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

toConstr :: HsUntypedSpliceResult a -> Constr Source #

dataTypeOf :: HsUntypedSpliceResult a -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data HsUserSpliceExt #

Information about a user-written splice, discovered by the renamer See Note [Lifecycle of an untyped splice, and PendingRnSplice]

Constructors

HsUserSpliceExt
Fields user_splice_flavour :: UntypedSpliceFlavour

Instances

Instances details

Data HsUserSpliceExt #

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) -> HsUserSpliceExt -> c HsUserSpliceExt Source #

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

toConstr :: HsUserSpliceExt -> Constr Source #

dataTypeOf :: HsUserSpliceExt -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data HsWrap (hs_syn :: Type -> Type) #

HsWrap appears only in typechecker output

Constructors

HsWrap HsWrapper (hs_syn GhcTc)

Instances

Instances details

(Data (hs_syn GhcTc), Typeable hs_syn) => Data (HsWrap hs_syn) #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: HsWrap hs_syn -> Constr Source #

dataTypeOf :: HsWrap hs_syn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data MatchGroupTc #

Constructors

MatchGroupTc
Fields mg_arg_tys :: [Scaled Type] mg_res_ty :: Type mg_origin :: Origin

Instances

Instances details

Data MatchGroupTc #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: MatchGroupTc -> Constr Source #

dataTypeOf :: MatchGroupTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data PendingRnSplice #

Constructors

PendingRnSplice SplicePointName (HsUntypedSplice GhcRn)

Instances

Instances details

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

data PendingTcSplice #

Pending Type-checker Splice See Note [Lifecycle of an untyped splice, and PendingRnSplice]

Constructors

PendingTcSplice SplicePointName (LHsExpr GhcTc)

Instances

Instances details

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

type PostTcExpr = HsExpr GhcTc #

Post-Type checking Expression

PostTcExpr is an evidence expression attached to the syntax tree by the type checker (c.f. postTcType).

type PostTcTable = [(Name, PostTcExpr)] #

Post-Type checking Table

We use a PostTcTable where there are a bunch of pieces of evidence, more than is convenient to keep individually.

data RecStmtTc #

Constructors

RecStmtTc
Fields recS_bind_ty :: Type recS_later_rets :: [PostTcExpr] recS_rec_rets :: [PostTcExpr] recS_ret_ty :: Type

Instances

Instances details

Data RecStmtTc #

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) -> RecStmtTc -> c RecStmtTc Source #

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

toConstr :: RecStmtTc -> Constr Source #

dataTypeOf :: RecStmtTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

type SplicePointName = Name #

type family SyntaxExprGhc (p :: Pass) = (r :: Type) | r -> p where ... #

Equations

SyntaxExprGhc 'Parsed = NoExtField
SyntaxExprGhc 'Renamed = SyntaxExprRn
SyntaxExprGhc 'Typechecked = SyntaxExprTc

data SyntaxExprRn #

The function to use in rebindable syntax. See Note [NoSyntaxExpr].

Constructors

SyntaxExprRn (HsExpr GhcRn)
NoSyntaxExprRn

Instances

Instances details

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

data SyntaxExprTc #

An expression with wrappers, used for rebindable syntax

This should desugar to

syn_res_wrap $ syn_expr (syn_arg_wraps[0] arg0)
                        (syn_arg_wraps[1] arg1) ...

where the actual arguments come from elsewhere in the AST.

Constructors

SyntaxExprTc
Fields syn_expr :: HsExpr GhcTc syn_arg_wraps :: [HsWrapper] syn_res_wrap :: HsWrapper
NoSyntaxExprTc

Instances

Instances details

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

newtype ThModFinalizers #

Finalizers produced by a splice with addModFinalizer

See Note [Delaying modFinalizers in untyped splices] in GHC.Rename.Splice. For how this is used.

Constructors

ThModFinalizers [ForeignRef (Q ())]

Instances

Instances details

Data ThModFinalizers #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: ThModFinalizers -> Constr Source #

dataTypeOf :: ThModFinalizers -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data UntypedSpliceFlavour #

Constructors

UntypedExpSplice
UntypedPatSplice
UntypedTypeSplice
UntypedDeclSplice

Instances

Instances details

Data UntypedSpliceFlavour #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: UntypedSpliceFlavour -> Constr Source #

dataTypeOf :: UntypedSpliceFlavour -> DataType Source #

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

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

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

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

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

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

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

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

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

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

type family XApplicativeArgMany x #

Instances

Instances details

type XApplicativeArgMany (GhcPass _1) #
Instance details Defined in GHC.Hs.Expr type XApplicativeArgMany (GhcPass _1) = NoExtField

type family XApplicativeArgOne x #

Instances

Instances details

type XApplicativeArgOne GhcPs #
Instance details Defined in GHC.Hs.Expr type XApplicativeArgOne GhcPs = NoExtField
type XApplicativeArgOne GhcRn #
Instance details Defined in GHC.Hs.Expr type XApplicativeArgOne GhcRn = FailOperator GhcRn
type XApplicativeArgOne GhcTc #
Instance details Defined in GHC.Hs.Expr type XApplicativeArgOne GhcTc = FailOperator GhcTc

type family XApplicativeStmt x x' #

Instances

Instances details

type XApplicativeStmt (GhcPass _1) GhcPs #
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcPs = NoExtField
type XApplicativeStmt (GhcPass _1) GhcRn #
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcRn = NoExtField
type XApplicativeStmt (GhcPass _1) GhcTc #
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcTc = Type

data XBindStmtRn #

Constructors

XBindStmtRn
Fields xbsrn_bindOp :: SyntaxExpr GhcRn xbsrn_failOp :: FailOperator GhcRn

Instances

Instances details

Data XBindStmtRn #

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) -> XBindStmtRn -> c XBindStmtRn Source #

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

toConstr :: XBindStmtRn -> Constr Source #

dataTypeOf :: XBindStmtRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data XBindStmtTc #

Constructors

XBindStmtTc
Fields xbstc_bindOp :: SyntaxExpr GhcTc xbstc_boundResultType :: Type xbstc_boundResultMult :: Mult xbstc_failOp :: FailOperator GhcTc

Instances

Instances details

Data XBindStmtTc #

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) -> XBindStmtTc -> c XBindStmtTc Source #

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

toConstr :: XBindStmtTc -> Constr Source #

dataTypeOf :: XBindStmtTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

type family XXApplicativeArg x #

Instances

Instances details

type XXApplicativeArg (GhcPass _1) #
Instance details Defined in GHC.Hs.Expr type XXApplicativeArg (GhcPass _1) = DataConCantHappen

data XXExprGhcRn #

Constructors

ExpandedThingRn
Fields xrn_orig :: HsThingRn xrn_expanded :: HsExpr GhcRn
PopErrCtxt !(LHsExpr GhcRn)
HsRecSelRn (FieldOcc GhcRn)	Variable pointing to record selector See Note [Non-overloaded record field selectors] and Note [Record selectors in the AST]

Instances

Instances details

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

data XXExprGhcTc #

Constructors

WrapExpr HsWrapper (HsExpr GhcTc)
ExpandedThingTc
Fields xtc_orig :: HsThingRn xtc_expanded :: HsExpr GhcTc
ConLikeTc ConLike [TcTyVar] [Scaled TcType]
HsTick CoreTickish (LHsExpr GhcTc)
HsBinTick Int Int (LHsExpr GhcTc)
HsRecSelTc (FieldOcc GhcTc)	Variable pointing to record selector See Note [Non-overloaded record field selectors] and Note [Record selectors in the AST]

Instances

Instances details

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

Orphan instances

Outputable HsArrowMatchContext #
Instance details Methods ppr :: HsArrowMatchContext -> SDoc #
Outputable HsLamVariant #
Instance details Methods ppr :: HsLamVariant -> SDoc #
OutputableBndrId p => Outputable (ArithSeqInfo (GhcPass p)) #
Instance details Methods ppr :: ArithSeqInfo (GhcPass p) -> SDoc #
UnXRec p => Outputable (DotFieldOcc p) #
Instance details Methods ppr :: DotFieldOcc p -> SDoc #
(UnXRec p, Outputable (XRec p FieldLabelString)) => Outputable (FieldLabelStrings p) #
Instance details Methods ppr :: FieldLabelStrings p -> SDoc #
OutputableBndrId p => Outputable (HsCmd (GhcPass p)) #
Instance details Methods ppr :: HsCmd (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsCmdTop (GhcPass p)) #
Instance details Methods ppr :: HsCmdTop (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsExpr (GhcPass p)) #
Instance details Methods ppr :: HsExpr (GhcPass p) -> SDoc #
Outputable fn => Outputable (HsMatchContext fn) #
Instance details Methods ppr :: HsMatchContext fn -> SDoc #
Outputable (HsPragE (GhcPass p)) #
Instance details Methods ppr :: HsPragE (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsQuote (GhcPass p)) #
Instance details Methods ppr :: HsQuote (GhcPass p) -> SDoc #
Outputable fn => Outputable (HsStmtContext fn) #
Instance details Methods ppr :: HsStmtContext fn -> SDoc #
(UnXRec p, Outputable (XRec p FieldLabelString)) => OutputableBndr (Located (FieldLabelStrings p)) #
Instance details Methods pprBndr :: BindingSite -> Located (FieldLabelStrings p) -> SDoc # pprPrefixOcc :: Located (FieldLabelStrings p) -> SDoc # pprInfixOcc :: Located (FieldLabelStrings p) -> SDoc # bndrIsJoin_maybe :: Located (FieldLabelStrings p) -> JoinPointHood #
(UnXRec p, Outputable (XRec p FieldLabelString)) => OutputableBndr (FieldLabelStrings p) #
Instance details Methods pprBndr :: BindingSite -> FieldLabelStrings p -> SDoc # pprPrefixOcc :: FieldLabelStrings p -> SDoc # pprInfixOcc :: FieldLabelStrings p -> SDoc # bndrIsJoin_maybe :: FieldLabelStrings p -> JoinPointHood #
HasAnnotation (Anno a) => WrapXRec (GhcPass p) a #
Instance details Methods wrapXRec :: a -> XRec (GhcPass p) a #
(OutputableBndrId pr, Outputable body) => Outputable (Match (GhcPass pr) body) #
Instance details Methods ppr :: Match (GhcPass pr) body -> SDoc #
(Outputable (StmtLR (GhcPass idL) (GhcPass idL) (LHsExpr (GhcPass idL))), Outputable (XXParStmtBlock (GhcPass idL) (GhcPass idR))) => Outputable (ParStmtBlock (GhcPass idL) (GhcPass idR)) #
Instance details Methods ppr :: ParStmtBlock (GhcPass idL) (GhcPass idR) -> SDoc #
(OutputableBndrId pl, OutputableBndrId pr, Anno (StmtLR (GhcPass pl) (GhcPass pr) body) ~ SrcSpanAnnA, Outputable body) => Outputable (StmtLR (GhcPass pl) (GhcPass pr) body) #
Instance details Methods ppr :: StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc #