GHC.Hs.Expr

ghc-lib-parser-9.14.1.20251220: 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
- pprLExpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (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
- data HsUntypedSpliceResult thing
  - = HsUntypedSpliceTop {
    - utsplice_result_finalizers :: ThModFinalizers
    - utsplice_result :: thing
    }
  - | HsUntypedSpliceNested SplicePointName
- prependQualified :: Maybe ModuleName -> SDoc -> SDoc
- lamCaseKeyword :: HsLamVariant -> SDoc
- data HoleKind
  - = HoleVar (LIdP GhcPs)
  - | HoleError
- data HsImplicitLiftSplice = HsImplicitLiftSplice {
  - implicit_lift_bind_lvl :: Set ThLevelIndex
  - implicit_lift_used_lvl :: ThLevelIndex
  - implicit_lift_gre :: Maybe GlobalRdrElt
  - implicit_lift_lid :: LIdOccP GhcRn
  }
- data PendingTcSplice = PendingTcSplice SplicePointName (LHsExpr GhcTc)
- data PendingRnSplice = PendingRnSplice SplicePointName (HsUntypedSplice 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 -> HsTypedSplice (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
- 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 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 "]"
  }
- unnamedHoleRdrName :: RdrName
- data AnnFunRhs = AnnFunRhs {
  - afr_strict :: EpToken "!"
  - afr_opens :: [EpToken "("]
  - afr_closes :: [EpToken ")"]
  }
- multAnnToHsExpr :: HsMultAnnOf (LocatedA (HsExpr GhcRn)) GhcRn -> Maybe (LocatedA (HsExpr GhcRn))
- mkHsVar :: forall (p :: Pass). IsPass p => LIdP (GhcPass p) -> HsExpr (GhcPass p)
- mkHsVarWithUserRdr :: forall (p :: Pass). IsPass p => RdrName -> LIdP (GhcPass p) -> HsExpr (GhcPass p)
- 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
- data HsTypedSpliceResult
  - = HsTypedSpliceTop
  - | HsTypedSpliceNested SplicePointName
- 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)]
- isInfixMatch :: forall (p :: Pass) body. Match (GhcPass p) body -> Bool
- 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 HsUserSpliceExt = HsUserSpliceExt {
  - user_splice_flavour :: UntypedSpliceFlavour
  }
- data HsQuasiQuoteExt = HsQuasiQuoteExt {
  - quasi_quote_flavour :: UntypedSpliceFlavour
  }
- data UntypedSpliceFlavour
  - = UntypedExpSplice
  - | UntypedPatSplice
  - | UntypedTypeSplice
  - | UntypedDeclSplice
- 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 p => HsMatchContext p -> 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 #

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

pprLExpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (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 #

data HsUntypedSpliceResult thing #

Constructors

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

#### Instances

Instances details

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

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

lamCaseKeyword :: HsLamVariant -> SDoc #

data HoleKind #

Constructors

HoleVar (LIdP GhcPs) |
HoleError |

#### Instances

Instances details

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

data HsImplicitLiftSplice #

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

Constructors

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

#### Instances

Instances details

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

data PendingTcSplice #

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

Constructors

PendingTcSplice SplicePointName (LHsExpr GhcTc) |

#### Instances

Instances details

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

data PendingRnSplice #

Constructors

PendingRnSplice SplicePointName (HsUntypedSplice GhcRn) |

#### Instances

Instances details

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

type SplicePointName = Name #

data SyntaxExprTc #

An expression with wrappers, used for rebindable syntax

This should desugar to

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

where the actual arguments come from elsewhere in the AST.

Constructors

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

#### Instances

Instances details

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

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

newtype ThModFinalizers #

Finalizers produced by a splice with `addModFinalizer`

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

Constructors

ThModFinalizers [ForeignRef (Q ())] |

#### Instances

Instances details

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

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 #

Post-Type checking Expression

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

type PostTcTable = [(Name, PostTcExpr)] #

Post-Type checking Table

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

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

Equations

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

data SyntaxExprRn #

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

Constructors

SyntaxExprRn (HsExpr GhcRn) |
NoSyntaxExprRn |

#### Instances

Instances details

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

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

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

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

mkSyntaxExpr :: HsExpr GhcRn -> SyntaxExprRn #

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

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

HsWrap appears only in typechecker output

Constructors

HsWrap HsWrapper (hs_syn GhcTc) |

#### Instances

Instances details

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

data HsBracketTc #

Constructors

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

#### Instances

Instances details

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

data BracketAnn noE hasE #

Constructors

BracketNoE noE |
BracketHasE hasE |

#### Instances

Instances details

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

data EpAnnHsCase #

Constructors

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

#### Instances

Instances details

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

data EpAnnLam #

Constructors

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

#### Instances

Instances details

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

data AnnExplicitSum #

Constructors

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

#### Instances

Instances details

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

type HsMatchContextRn = HsMatchContext (LIdP GhcRn) #

data AnnsIf #

Constructors

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

#### Instances

Instances details

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

data family HsRecUpdParent x #

Information about the parent of a record update:

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

#### Instances

Instances details

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

data AnnProjection #

Constructors

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

#### Instances

Instances details

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

data AnnArithSeq #

Constructors

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

#### Instances

Instances details

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

unnamedHoleRdrName :: RdrName #

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

data AnnFunRhs #

Constructors

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

#### Instances

Instances details

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

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

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

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

data AnnFieldLabel #

Constructors

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

#### Instances

Instances details

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

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 #

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

data XXExprGhcTc #

Constructors

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

#### Instances

Instances details

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

data HsThingRn #

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

Constructors

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

#### Instances

Instances details

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

isHsThingRnExpr :: HsThingRn -> Bool #

isHsThingRnStmt :: HsThingRn -> Bool #

isHsThingRnPat :: HsThingRn -> Bool #

mkPopErrCtxtExpr :: LHsExpr GhcRn -> HsExpr GhcRn #

Wrap a located expression with a `PopErrCtxt`

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

Wrap a located expression with a PopSrcExpr with an appropriate location

mkExpandedExpr #

Arguments

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

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

mkExpandedStmt #

Arguments

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

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

mkExpandedPatRn #

Arguments

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

mkExpandedStmtAt #

Arguments

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

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

mkExpandedStmtPopAt #

Arguments

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

Wrap the expanded version of the expression with a pop.

mkExpandedExprTc #

Arguments

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

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

mkExpandedStmtTc #

Arguments

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

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

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 #

data HsTypedSpliceResult #

Constructors

HsTypedSpliceTop |
HsTypedSpliceNested SplicePointName |

#### Instances

Instances details

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

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 #

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

Parenthesize an expression without token information

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

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

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

Command Syntax Table (for Arrow syntax)

data CmdTopTc #

Constructors

CmdTopTc Type Type (CmdSyntaxTable GhcTc) |

#### Instances

Instances details

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

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 #

Constructors

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

#### Instances

Instances details

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

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 #

Is there only one RHS in this list of matches?

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

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

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

data GrhsAnn #

Constructors

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

#### Instances

Instances details

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

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 #

Constructors

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

#### Instances

Instances details

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

data XBindStmtRn #

Constructors

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

#### Instances

Instances details

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

data XBindStmtTc #

Constructors

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

#### Instances

Instances details

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

type family XApplicativeStmt x x' #

#### Instances

Instances details

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

data AnnTransStmt #

Constructors

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

#### Instances

Instances details

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

data ApplicativeStmt idL idR #

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

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

Constructors

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

#### Instances

Instances details

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

data ApplicativeArg idL #

Applicative Argument

Constructors

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

#### Instances

Instances details

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

type family XApplicativeArgOne x #

#### Instances

Instances details

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

type family XApplicativeArgMany x #

#### Instances

Instances details

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

type family XXApplicativeArg x #

#### Instances

Instances details

type XXApplicativeArg (GhcPass _1) # |
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 #

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 #

Constructors

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

#### Instances

Instances details

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

data HsUserSpliceExt #

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

Constructors

HsUserSpliceExt |
Fields user_splice_flavour :: UntypedSpliceFlavour

#### Instances

Instances details

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

data HsQuasiQuoteExt #

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

Constructors

HsQuasiQuoteExt |
Fields quasi_quote_flavour :: UntypedSpliceFlavour

#### Instances

Instances details

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

data UntypedSpliceFlavour #

Constructors

UntypedExpSplice |
UntypedPatSplice |
UntypedTypeSplice |
UntypedDeclSplice |

#### Instances

Instances details

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

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 p => HsMatchContext p -> 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 #

# Orphan instances

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