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

Safe Haskell | Ignore
Language | GHC2021

GHC.Hs.Expr

Contents

- Orphan instances

Description

Abstract Haskell syntax for expressions.

Synopsis

- module Language.Haskell.Syntax.Expr
- pprParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> HsExpr (GhcPass p) -> SDoc
- pprExpr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc
- pprFunBind :: forall (idR :: Pass). OutputableBndrId idR => MatchGroup (GhcPass idR) (LHsExpr (GhcPass idR)) -> SDoc
- pprPatBind :: forall (bndr :: Pass) (p :: Pass). (OutputableBndrId bndr, OutputableBndrId p) => LPat (GhcPass bndr) -> GRHSs (GhcPass p) (LHsExpr (GhcPass p)) -> SDoc
- pprUntypedSplice :: forall (p :: Pass). OutputableBndrId p => Bool -> Maybe SplicePointName -> HsUntypedSplice (GhcPass p) -> SDoc
- pprLExpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc
- data HsUntypedSpliceResult thing
  - = HsUntypedSpliceTop {
    - utsplice_result_finalizers :: ThModFinalizers
    - utsplice_result :: thing
    }
  - | HsUntypedSpliceNested SplicePointName
- prependQualified :: Maybe ModuleName -> SDoc -> SDoc
- lamCaseKeyword :: HsLamVariant -> SDoc
- data PendingTcSplice = PendingTcSplice SplicePointName (LHsExpr GhcTc)
- data PendingRnSplice = PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)
- type SplicePointName = Name
- data SyntaxExprTc
  - = SyntaxExprTc {
    - syn_expr :: HsExpr GhcTc
    - syn_arg_wraps :: [HsWrapper]
    - syn_res_wrap :: HsWrapper
    }
  - | NoSyntaxExprTc
- pprTypedSplice :: forall (p :: Pass). OutputableBndrId p => Maybe SplicePointName -> LHsExpr (GhcPass p) -> SDoc
- newtype ThModFinalizers = ThModFinalizers [ForeignRef (Q ())]
- pp_rhs :: Outputable body => HsMatchContext fn -> body -> SDoc
- ppr_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc
- pprArg :: forall (idL :: Pass). OutputableBndrId idL => ApplicativeArg (GhcPass idL) -> SDoc
- type PostTcExpr = HsExpr GhcTc
- type PostTcTable = [(Name, PostTcExpr)]
- type family SyntaxExprGhc (p :: Pass) = (r :: Type) | r -> p where ...
- data SyntaxExprRn
  - = SyntaxExprRn (HsExpr GhcRn)
  - | NoSyntaxExprRn
- noExpr :: forall (p :: Pass). HsExpr (GhcPass p)
- noSyntaxExpr :: forall (p :: Pass). IsPass p => SyntaxExpr (GhcPass p)
- mkSyntaxExpr :: HsExpr GhcRn -> SyntaxExprRn
- mkRnSyntaxExpr :: Name -> SyntaxExprRn
- data HsWrap (hs_syn :: Type -> Type) = HsWrap HsWrapper (hs_syn GhcTc)
- data HsBracketTc = HsBracketTc {
  - hsb_quote :: HsQuote GhcRn
  - hsb_ty :: Type
  - hsb_wrap :: Maybe QuoteWrapper
  - hsb_splices :: [PendingTcSplice]
  }
- data BracketAnn noE hasE
  - = BracketNoE noE
  - | BracketHasE hasE
- data EpAnnHsCase = EpAnnHsCase {
  - hsCaseAnnCase :: EpToken "case"
  - hsCaseAnnOf :: EpToken "of"
  }
- data EpAnnLam = EpAnnLam {
  - epl_lambda :: EpToken "\\"
  - epl_case :: Maybe EpaLocation
  }
- data EpAnnUnboundVar = EpAnnUnboundVar {
  - hsUnboundBackquotes :: (EpToken "`", EpToken "`")
  - hsUnboundHole :: EpToken "_"
  }
- data AnnExplicitSum = AnnExplicitSum {
  - aesOpen :: EpaLocation
  - aesBarsBefore :: [EpToken "|"]
  - aesBarsAfter :: [EpToken "|"]
  - aesClose :: EpaLocation
  }
- type HsMatchContextRn = HsMatchContext (LIdP GhcRn)
- data AnnsIf = AnnsIf {
  - aiIf :: EpToken "if"
  - aiThen :: EpToken "then"
  - aiElse :: EpToken "else"
  - aiThenSemi :: Maybe (EpToken ";")
  - aiElseSemi :: Maybe (EpToken ";")
  }
- data family HsRecUpdParent x
- data AnnProjection = AnnProjection {
  - apOpen :: EpToken "("
  - apClose :: EpToken ")"
  }
- data AnnArithSeq = AnnArithSeq {
  - aas_open :: EpToken "["
  - aas_comma :: Maybe (EpToken ",")
  - aas_dotdot :: EpToken ".."
  - aas_close :: EpToken "]"
  }
- data AnnFunRhs = AnnFunRhs {
  - afr_strict :: EpToken "!"
  - afr_opens :: [EpToken "("]
  - afr_closes :: [EpToken ")"]
  }
- arrowToHsExpr :: HsArrowOf (LocatedA (HsExpr GhcRn)) GhcRn -> LocatedA (HsExpr GhcRn)
- data AnnFieldLabel = AnnFieldLabel {
  - afDot :: Maybe (EpToken ".")
  }
- 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)]
- 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)
- data HsThingRn
  - = OrigExpr (HsExpr GhcRn)
  - | OrigStmt (ExprLStmt GhcRn)
  - | OrigPat (LPat GhcRn)
- isHsThingRnExpr :: HsThingRn -> Bool
- isHsThingRnStmt :: HsThingRn -> Bool
- isHsThingRnPat :: HsThingRn -> Bool
- mkPopErrCtxtExpr :: LHsExpr GhcRn -> HsExpr GhcRn
- mkPopErrCtxtExprAt :: SrcSpanAnnA -> LHsExpr GhcRn -> LHsExpr GhcRn
- mkExpandedExpr :: HsExpr GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
- mkExpandedStmt :: ExprLStmt GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
- mkExpandedPatRn :: LPat GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
- mkExpandedStmtAt :: SrcSpanAnnA -> ExprLStmt GhcRn -> HsExpr GhcRn -> LHsExpr GhcRn
- mkExpandedStmtPopAt :: SrcSpanAnnA -> ExprLStmt GhcRn -> HsExpr GhcRn -> LHsExpr GhcRn
- mkExpandedExprTc :: HsExpr GhcRn -> HsExpr GhcTc -> HsExpr GhcTc
- mkExpandedStmtTc :: ExprLStmt GhcRn -> HsExpr GhcTc -> HsExpr GhcTc
- isAtomicHsExpr :: forall (p :: Pass). IsPass p => HsExpr (GhcPass p) -> Bool
- isQuietHsExpr :: HsExpr id -> Bool
- pprBinds :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
- ppr_lexpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc
- ppr_apps :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))] -> SDoc
- ppr_infix_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> Maybe SDoc
- pprDebugParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc
- pprMatches :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => MatchGroup (GhcPass idR) body -> SDoc
- pprDo :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => HsDoFlavour -> [LStmt (GhcPass p) body] -> SDoc
- thTyBrackets :: SDoc -> SDoc
- ppr_with_pending_tc_splices :: SDoc -> [PendingTcSplice] -> SDoc
- ppr_infix_expr_rn :: XXExprGhcRn -> Maybe SDoc
- ppr_infix_expr_tc :: XXExprGhcTc -> Maybe SDoc
- ppr_infix_hs_expansion :: HsThingRn -> Maybe SDoc
- pprParendLExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc
- hsExprNeedsParens :: forall (p :: Pass). IsPass p => PprPrec -> HsExpr (GhcPass p) -> Bool
- gHsPar :: forall (p :: Pass). IsPass p => LHsExpr (GhcPass p) -> HsExpr (GhcPass p)
- parenthesizeHsExpr :: forall (p :: Pass). IsPass p => PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
- stripParensLHsExpr :: forall (p :: Pass). LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
- stripParensHsExpr :: forall (p :: Pass). HsExpr (GhcPass p) -> HsExpr (GhcPass p)
- type CmdSyntaxTable p = [(Name, HsExpr p)]
- data CmdTopTc = CmdTopTc Type Type (CmdSyntaxTable GhcTc)
- pprCmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc
- pprLCmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc
- isQuietHsCmd :: HsCmd id -> Bool
- ppr_cmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc
- ppr_lcmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc
- pprArrowExpr :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc
- pprCmdArg :: forall (p :: Pass). OutputableBndrId p => HsCmdTop (GhcPass p) -> SDoc
- data MatchGroupTc = MatchGroupTc {
  - mg_arg_tys :: [Scaled Type]
  - mg_res_ty :: Type
  - mg_origin :: Origin
  }
- pprMatch :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc
- isEmptyMatchGroup :: forall (p :: Pass) body. MatchGroup (GhcPass p) body -> Bool
- isSingletonMatchGroup :: forall (p :: Pass) body. [LMatch (GhcPass p) body] -> Bool
- matchGroupArity :: forall (id :: Pass) body. MatchGroup (GhcPass id) body -> Arity
- hsLMatchPats :: forall (id :: Pass) body. LMatch (GhcPass id) body -> [LPat (GhcPass id)]
- data GrhsAnn = GrhsAnn {
  - ga_vbar :: Maybe (EpToken "|")
  - ga_sep :: Either (EpToken "=") TokRarrow
  }
- pprGRHSs :: forall (idR :: Pass) body fn. (OutputableBndrId idR, Outputable body) => HsMatchContext fn -> GRHSs (GhcPass idR) body -> SDoc
- pprGRHS :: forall (idR :: Pass) body fn. (OutputableBndrId idR, Outputable body) => HsMatchContext fn -> GRHS (GhcPass idR) body -> SDoc
- matchSeparator :: HsMatchContext fn -> SDoc
- data RecStmtTc = RecStmtTc {
  - recS_bind_ty :: Type
  - recS_later_rets :: [PostTcExpr]
  - recS_rec_rets :: [PostTcExpr]
  - recS_ret_ty :: Type
  }
- 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 XApplicativeStmt x x'
- data AnnTransStmt = AnnTransStmt {
  - ats_then :: EpToken "then"
  - ats_group :: Maybe (EpToken "group")
  - ats_by :: Maybe (EpToken "by")
  - ats_using :: Maybe (EpToken "using")
  }
- data ApplicativeStmt idL idR = ApplicativeStmt (XApplicativeStmt idL idR) [(SyntaxExpr idR, ApplicativeArg idL)] (Maybe (SyntaxExpr idR))
- 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)
- type family XApplicativeArgOne x
- type family XApplicativeArgMany x
- type family XXApplicativeArg x
- 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
- pprBindStmt :: (Outputable pat, Outputable expr) => pat -> expr -> SDoc
- pprTransStmt :: Outputable body => Maybe body -> body -> TransForm -> 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
- pprTransformStmt :: forall (p :: Pass). OutputableBndrId p => [IdP (GhcPass p)] -> LHsExpr (GhcPass p) -> Maybe (LHsExpr (GhcPass p)) -> SDoc
- pprBy :: Outputable body => Maybe body -> SDoc
- ppr_module_name_prefix :: Maybe ModuleName -> SDoc
- pprComp :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc
- pprQuals :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc
- data DelayedSplice = DelayedSplice TcLclEnv (LHsExpr GhcRn) TcType (LHsExpr GhcTc)
- data UntypedSpliceFlavour
  - = UntypedExpSplice
  - | UntypedPatSplice
  - | UntypedTypeSplice
  - | UntypedDeclSplice
- pprPendingSplice :: forall (p :: Pass). OutputableBndrId p => SplicePointName -> LHsExpr (GhcPass p) -> SDoc
- ppr_splice :: forall (p :: Pass). OutputableBndrId p => SDoc -> Maybe SplicePointName -> LHsExpr (GhcPass p) -> SDoc
- ppr_quasi :: OutputableBndr p => p -> FastString -> SDoc
- thBrackets :: SDoc -> SDoc -> SDoc
- pp_dotdot :: SDoc
- type HsMatchContextPs = HsMatchContext (LIdP GhcPs)
- type HsStmtContextRn = HsStmtContext (LIdP GhcRn)
- pprExternalSrcLoc :: (StringLiteral, (Int, Int), (Int, Int)) -> SDoc
- pprHsArrType :: HsArrAppType -> SDoc
- pprStmtContext :: Outputable fn => HsStmtContext fn -> SDoc
- matchContextErrString :: Outputable fn => HsMatchContext fn -> SDoc
- matchArrowContextErrString :: HsArrowMatchContext -> SDoc
- matchDoContextErrString :: HsDoFlavour -> SDoc
- pprMatchInCtxt :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc
- pprMatchContext :: Outputable fn => HsMatchContext 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
- pprAStmtContext :: Outputable fn => HsStmtContext fn -> SDoc
- pprMatchContextNoun :: Outputable fn => HsMatchContext fn -> SDoc
- pprArrowMatchContextNoun :: HsArrowMatchContext -> SDoc
- pprMatchContextNouns :: Outputable fn => HsMatchContext fn -> SDoc
- pprArrowMatchContextNouns :: HsArrowMatchContext -> SDoc
- pprAHsDoFlavour :: HsDoFlavour -> SDoc
- pprHsDoFlavour :: HsDoFlavour -> SDoc
- pprStmtCat :: forall (p :: Pass) body. IsPass p => Stmt (GhcPass p) body -> SDoc
- pprFieldLabelStrings :: (UnXRec p, Outputable (XRec p FieldLabelString)) => FieldLabelStrings p -> SDoc
- pprPrefixFastString :: FastString -> SDoc

# Documentation

module Language.Haskell.Syntax.Expr

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

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

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

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

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

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

data HsUntypedSpliceResult thing Source #

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

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 #

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

lamCaseKeyword :: HsLamVariant -> SDoc Source #

data PendingTcSplice Source #

Pending Type-checker Splice

Constructors

PendingTcSplice SplicePointName (LHsExpr GhcTc) |

#### Instances

Instances details

Data PendingTcSplice Source # |

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 #

Outputable PendingTcSplice Source # |
Instance details Defined in GHC.Hs.Expr Methods ppr :: PendingTcSplice -> SDoc Source #

data PendingRnSplice Source #

Pending Renamer Splice

Constructors

PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn) |

#### Instances

Instances details

Data PendingRnSplice Source # |

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 #

Outputable PendingRnSplice Source # |
Instance details Defined in GHC.Hs.Expr Methods ppr :: PendingRnSplice -> SDoc Source #

type SplicePointName = Name Source #

data SyntaxExprTc Source #

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

Data SyntaxExprTc Source # |

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 #

Outputable SyntaxExprTc Source # |
Instance details Defined in GHC.Hs.Expr Methods ppr :: SyntaxExprTc -> SDoc Source #

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

newtype ThModFinalizers Source #

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

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 #

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

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

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

type PostTcExpr = HsExpr GhcTc Source #

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

Post-Type checking Table

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

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

Equations

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

data SyntaxExprRn Source #

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

Constructors

SyntaxExprRn (HsExpr GhcRn) |
NoSyntaxExprRn |

#### Instances

Instances details

Data SyntaxExprRn Source # |

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 #

Outputable SyntaxExprRn Source # |
Instance details Defined in GHC.Hs.Expr Methods ppr :: SyntaxExprRn -> SDoc Source #

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

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

mkSyntaxExpr :: HsExpr GhcRn -> SyntaxExprRn Source #

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

mkRnSyntaxExpr :: Name -> SyntaxExprRn Source #

Make a `SyntaxExpr` from a `Name` (the "rn" is because this is used in the renamer).

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

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

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

Constructors

HsBracketTc |

Fields

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

#### Instances

Instances details

Data HsBracketTc Source # |

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 BracketAnn noE hasE Source #

Constructors

BracketNoE noE |
BracketHasE hasE |

#### Instances

Instances details

(Data noE, Data hasE) => Data (BracketAnn noE hasE) Source # |

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 #

(NoAnn n, NoAnn h) => NoAnn (BracketAnn n h) Source # |
Instance details Defined in GHC.Hs.Expr Methods noAnn :: BracketAnn n h Source #

data EpAnnHsCase Source #

Constructors

EpAnnHsCase |

Fields

- hsCaseAnnCase :: EpToken "case"
- hsCaseAnnOf :: EpToken "of"

#### Instances

Instances details

Data EpAnnHsCase Source # |

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 #

NoAnn EpAnnHsCase Source # |
Instance details Defined in GHC.Hs.Expr Methods noAnn :: EpAnnHsCase Source #

data EpAnnLam Source #

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

Data EpAnnLam Source # |

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 #

NoAnn EpAnnLam Source # |
Instance details Defined in GHC.Hs.Expr Methods noAnn :: EpAnnLam Source #

data EpAnnUnboundVar Source #

Constructors

EpAnnUnboundVar |

Fields

- hsUnboundBackquotes :: (EpToken "`", EpToken "`")
- hsUnboundHole :: EpToken "_"

#### Instances

Instances details

Data EpAnnUnboundVar Source # |

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

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

toConstr :: EpAnnUnboundVar -> Constr Source #

dataTypeOf :: EpAnnUnboundVar -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data AnnExplicitSum Source #

Constructors

AnnExplicitSum |

Fields

- aesOpen :: EpaLocation
- aesBarsBefore :: [EpToken "|"]
- aesBarsAfter :: [EpToken "|"]
- aesClose :: EpaLocation

#### Instances

Instances details

Data AnnExplicitSum Source # |

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 #

NoAnn AnnExplicitSum Source # |
Instance details Defined in GHC.Hs.Expr Methods noAnn :: AnnExplicitSum Source #

type HsMatchContextRn = HsMatchContext (LIdP GhcRn) Source #

data AnnsIf Source #

Constructors

AnnsIf |

Fields

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

#### Instances

Instances details

Data AnnsIf Source # |

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 #

NoAnn AnnsIf Source # |
Instance details Defined in GHC.Hs.Expr Methods noAnn :: AnnsIf Source #

data family HsRecUpdParent x Source #

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

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

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

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 Source # |
Instance details Defined in GHC.Hs.Expr data HsRecUpdParent GhcPs
data HsRecUpdParent GhcRn Source # |

Instance details

Defined in GHC.Hs.Expr

data HsRecUpdParent GhcRn = RnRecUpdParent {

- rnRecUpdLabels :: NonEmpty FieldGlobalRdrElt
- rnRecUpdCons :: UniqSet ConLikeName

}

data HsRecUpdParent GhcTc Source # |

Instance details

Defined in GHC.Hs.Expr

data HsRecUpdParent GhcTc = TcRecUpdParent {

- tcRecUpdParent :: RecSelParent
- tcRecUpdLabels :: NonEmpty FieldGlobalRdrElt
- tcRecUpdCons :: UniqSet ConLike

}

data AnnProjection Source #

Constructors

AnnProjection |

Fields

- apOpen :: EpToken "("
- apClose :: EpToken ")"

#### Instances

Instances details

Data AnnProjection Source # |

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 #

NoAnn AnnProjection Source # |
Instance details Defined in GHC.Hs.Expr Methods noAnn :: AnnProjection Source #

data AnnArithSeq Source #

Constructors

AnnArithSeq |

Fields

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

#### Instances

Instances details

Data AnnArithSeq Source # |

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 #

NoAnn AnnArithSeq Source # |
Instance details Defined in GHC.Hs.Expr Methods noAnn :: AnnArithSeq Source #

data AnnFunRhs Source #

Constructors

AnnFunRhs |

Fields

- afr_strict :: EpToken "!"
- afr_opens :: [EpToken "("]
- afr_closes :: [EpToken ")"]

#### Instances

Instances details

Data AnnFunRhs Source # |

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 #

NoAnn AnnFunRhs Source # |
Instance details Defined in GHC.Hs.Expr Methods noAnn :: AnnFunRhs Source #

arrowToHsExpr :: HsArrowOf (LocatedA (HsExpr GhcRn)) GhcRn -> LocatedA (HsExpr GhcRn) Source #

data AnnFieldLabel Source #

Constructors

AnnFieldLabel |

Fields

- afDot :: Maybe (EpToken ".")

#### Instances

Instances details

Data AnnFieldLabel Source # |

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 #

NoAnn AnnFieldLabel Source # |
Instance details Defined in GHC.Hs.Expr Methods noAnn :: AnnFieldLabel Source #

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

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

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

data XXExprGhcRn Source #

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

Data XXExprGhcRn Source # |

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 #

Outputable XXExprGhcRn Source # |
Instance details Defined in GHC.Hs.Expr Methods ppr :: XXExprGhcRn -> SDoc Source #

data XXExprGhcTc Source #

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

Data XXExprGhcTc Source # |

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 #

Outputable XXExprGhcTc Source # |
Instance details Defined in GHC.Hs.Expr Methods ppr :: XXExprGhcTc -> SDoc Source #

data HsThingRn Source #

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

Data HsThingRn Source # |

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 #

Outputable HsThingRn Source # |
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsThingRn -> SDoc Source #

isHsThingRnExpr :: HsThingRn -> Bool Source #

isHsThingRnStmt :: HsThingRn -> Bool Source #

isHsThingRnPat :: HsThingRn -> Bool Source #

mkPopErrCtxtExpr :: LHsExpr GhcRn -> HsExpr GhcRn Source #

Wrap a located expression with a `PopErrCtxt`

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

Wrap a located expression with a PopSrcExpr with an appropriate location

mkExpandedExpr Source #

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.

mkExpandedStmt Source #

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

mkExpandedPatRn Source #

Arguments

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

mkExpandedStmtAt Source #

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

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.

mkExpandedExprTc Source #

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.

mkExpandedStmtTc Source #

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.

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

isQuietHsExpr :: HsExpr id -> Bool Source #

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

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

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

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

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

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

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

thTyBrackets :: SDoc -> SDoc Source #

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

ppr_infix_expr_rn :: XXExprGhcRn -> Maybe SDoc Source #

ppr_infix_expr_tc :: XXExprGhcTc -> Maybe SDoc Source #

ppr_infix_hs_expansion :: HsThingRn -> Maybe SDoc Source #

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

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

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

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

Parenthesize an expression without token information

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

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

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

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

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

Command Syntax Table (for Arrow syntax)

data CmdTopTc Source #

Constructors

CmdTopTc Type Type (CmdSyntaxTable GhcTc) |

#### Instances

Instances details

Data CmdTopTc Source # |

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 #

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

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

isQuietHsCmd :: HsCmd id -> Bool Source #

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

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

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

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

data MatchGroupTc Source #

Constructors

MatchGroupTc |

Fields

- mg_arg_tys :: [Scaled Type]
- mg_res_ty :: Type
- mg_origin :: Origin

#### Instances

Instances details

Data MatchGroupTc Source # |

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 #

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

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

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

Is there only one RHS in this list of matches?

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

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

data GrhsAnn Source #

Constructors

GrhsAnn |

Fields

- ga_vbar :: Maybe (EpToken "|")
- ga_sep :: Either (EpToken "=") TokRarrow

  Match separator location, `=` or `->`

#### Instances

Instances details

Data GrhsAnn Source # |

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 #

NoAnn GrhsAnn Source # |
Instance details Defined in GHC.Hs.Expr Methods noAnn :: GrhsAnn Source #
Outputable GrhsAnn Source # |
Instance details Defined in GHC.Hs.Expr Methods ppr :: GrhsAnn -> SDoc Source #

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

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

matchSeparator :: HsMatchContext fn -> SDoc Source #

data RecStmtTc Source #

Constructors

RecStmtTc |

Fields

- recS_bind_ty :: Type
- recS_later_rets :: [PostTcExpr]
- recS_rec_rets :: [PostTcExpr]
- recS_ret_ty :: Type

#### Instances

Instances details

Data RecStmtTc Source # |

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 #

data XBindStmtRn Source #

Constructors

XBindStmtRn |

Fields

- xbsrn_bindOp :: SyntaxExpr GhcRn
- xbsrn_failOp :: FailOperator GhcRn

#### Instances

Instances details

Data XBindStmtRn Source # |

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

Constructors

XBindStmtTc |

Fields

- xbstc_bindOp :: SyntaxExpr GhcTc
- xbstc_boundResultType :: Type
- xbstc_boundResultMult :: Mult
- xbstc_failOp :: FailOperator GhcTc

#### Instances

Instances details

Data XBindStmtTc Source # |

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 XApplicativeStmt x x' Source #

#### Instances

Instances details

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

data AnnTransStmt Source #

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

Data AnnTransStmt Source # |

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 #

NoAnn AnnTransStmt Source # |
Instance details Defined in GHC.Hs.Expr Methods noAnn :: AnnTransStmt Source #

data ApplicativeStmt idL idR Source #

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

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

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

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

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

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

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

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

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

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 ApplicativeArg idL Source #

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

Data (ApplicativeArg GhcPs) Source # |

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

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

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 #

OutputableBndrId idL => Outputable (ApplicativeArg (GhcPass idL)) Source # |
Instance details Defined in GHC.Hs.Expr Methods ppr :: ApplicativeArg (GhcPass idL) -> SDoc Source #

type family XApplicativeArgOne x Source #

#### Instances

Instances details

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

type family XApplicativeArgMany x Source #

#### Instances

Instances details

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

type family XXApplicativeArg x Source #

#### Instances

Instances details

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

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

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

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

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

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

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

ppr_module_name_prefix :: Maybe ModuleName -> SDoc Source #

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

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

data DelayedSplice Source #

Constructors

DelayedSplice TcLclEnv (LHsExpr GhcRn) TcType (LHsExpr GhcTc) |

#### Instances

Instances details

Data DelayedSplice Source # |

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 UntypedSpliceFlavour Source #

Constructors

UntypedExpSplice |
UntypedPatSplice |
UntypedTypeSplice |
UntypedDeclSplice |

#### Instances

Instances details

Data UntypedSpliceFlavour Source # |

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 #

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

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

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

thBrackets :: SDoc -> SDoc -> SDoc Source #

pp_dotdot :: SDoc Source #

type HsMatchContextPs = HsMatchContext (LIdP GhcPs) Source #

type HsStmtContextRn = HsStmtContext (LIdP GhcRn) Source #

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

pprHsArrType :: HsArrAppType -> SDoc Source #

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

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

matchArrowContextErrString :: HsArrowMatchContext -> SDoc Source #

matchDoContextErrString :: HsDoFlavour -> SDoc Source #

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

pprMatchContext :: Outputable fn => HsMatchContext fn -> SDoc Source #

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

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

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

pprArrowMatchContextNoun :: HsArrowMatchContext -> SDoc Source #

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

pprArrowMatchContextNouns :: HsArrowMatchContext -> SDoc Source #

pprAHsDoFlavour :: HsDoFlavour -> SDoc Source #

pprHsDoFlavour :: HsDoFlavour -> SDoc Source #

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

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

pprPrefixFastString :: FastString -> SDoc Source #

# Orphan instances

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