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

Safe Haskell | Ignore
Language | GHC2021

GHC.Hs.Expr

Contents

- Orphan instances

Description

Abstract Haskell syntax for expressions.

Synopsis

- module Language.Haskell.Syntax.Expr
- pprParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> HsExpr (GhcPass p) -> SDoc
- pprExpr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc
- pprFunBind :: forall (idR :: Pass). OutputableBndrId idR => MatchGroup (GhcPass idR) (LHsExpr (GhcPass idR)) -> SDoc
- pprPatBind :: forall (bndr :: Pass) (p :: Pass). (OutputableBndrId bndr, OutputableBndrId p) => LPat (GhcPass bndr) -> GRHSs (GhcPass p) (LHsExpr (GhcPass p)) -> SDoc
- pprUntypedSplice :: forall (p :: Pass). OutputableBndrId p => Bool -> Maybe SplicePointName -> HsUntypedSplice (GhcPass p) -> SDoc
- pprLExpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc
- data HsUntypedSpliceResult thing
  - = HsUntypedSpliceTop {
    - utsplice_result_finalizers :: ThModFinalizers
    - utsplice_result :: thing
    }
  - | HsUntypedSpliceNested SplicePointName
- prependQualified :: Maybe ModuleName -> SDoc -> SDoc
- lamCaseKeyword :: HsLamVariant -> SDoc
- data PendingTcSplice = PendingTcSplice SplicePointName (LHsExpr GhcTc)
- data PendingRnSplice = PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)
- type SplicePointName = Name
- pp_rhs :: Outputable body => HsMatchContext fn -> body -> SDoc
- data SyntaxExprTc
  - = SyntaxExprTc {
    - syn_expr :: HsExpr GhcTc
    - syn_arg_wraps :: [HsWrapper]
    - syn_res_wrap :: HsWrapper
    }
  - | NoSyntaxExprTc
- pprTypedSplice :: forall (p :: Pass). OutputableBndrId p => Maybe SplicePointName -> LHsExpr (GhcPass p) -> SDoc
- newtype ThModFinalizers = ThModFinalizers [ForeignRef (Q ())]
- ppr_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc
- pprArg :: forall (idL :: Pass). OutputableBndrId idL => ApplicativeArg (GhcPass idL) -> SDoc
- type PostTcExpr = HsExpr GhcTc
- type PostTcTable = [(Name, PostTcExpr)]
- type family SyntaxExprGhc (p :: Pass) = (r :: Type) | r -> p where ...
- data SyntaxExprRn
  - = SyntaxExprRn (HsExpr GhcRn)
  - | NoSyntaxExprRn
- noExpr :: forall (p :: Pass). HsExpr (GhcPass p)
- noSyntaxExpr :: forall (p :: Pass). IsPass p => SyntaxExpr (GhcPass p)
- mkSyntaxExpr :: HsExpr GhcRn -> SyntaxExprRn
- mkRnSyntaxExpr :: Name -> SyntaxExprRn
- data HsWrap (hs_syn :: Type -> Type) = HsWrap HsWrapper (hs_syn GhcTc)
- data HsBracketTc = HsBracketTc {
  - hsb_quote :: HsQuote GhcRn
  - hsb_ty :: Type
  - hsb_wrap :: Maybe QuoteWrapper
  - hsb_splices :: [PendingTcSplice]
  }
- data EpAnnHsCase = EpAnnHsCase {
  - hsCaseAnnCase :: EpaLocation
  - hsCaseAnnOf :: EpaLocation
  - hsCaseAnnsRest :: [AddEpAnn]
  }
- data EpAnnUnboundVar = EpAnnUnboundVar {
  - hsUnboundBackquotes :: (EpaLocation, EpaLocation)
  - hsUnboundHole :: EpaLocation
  }
- data AnnExplicitSum = AnnExplicitSum {
  - aesOpen :: EpaLocation
  - aesBarsBefore :: [EpaLocation]
  - aesBarsAfter :: [EpaLocation]
  - aesClose :: EpaLocation
  }
- type HsMatchContextRn = HsMatchContext (LIdP GhcRn)
- data AnnsIf = AnnsIf {
  - aiIf :: EpaLocation
  - aiThen :: EpaLocation
  - aiElse :: EpaLocation
  - aiThenSemi :: Maybe EpaLocation
  - aiElseSemi :: Maybe EpaLocation
  }
- data family HsRecUpdParent x
- data AnnProjection = AnnProjection {
  - apOpen :: EpaLocation
  - apClose :: EpaLocation
  }
- data AnnFieldLabel = AnnFieldLabel {
  - afDot :: Maybe EpaLocation
  }
- 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)
- data XXExprGhcTc
  - = WrapExpr !(HsWrap HsExpr)
  - | ExpandedThingTc {
    - xtc_orig :: HsThingRn
    - xtc_expanded :: HsExpr GhcTc
    }
  - | ConLikeTc ConLike [TcTyVar] [Scaled TcType]
  - | HsTick CoreTickish (LHsExpr GhcTc)
  - | HsBinTick Int Int (LHsExpr GhcTc)
- data HsThingRn
  - = OrigExpr (HsExpr GhcRn)
  - | OrigStmt (ExprLStmt GhcRn)
  - | OrigPat (LPat GhcRn)
- isHsThingRnExpr :: HsThingRn -> Bool
- isHsThingRnStmt :: HsThingRn -> Bool
- isHsThingRnPat :: HsThingRn -> Bool
- mkPopErrCtxtExpr :: LHsExpr GhcRn -> HsExpr GhcRn
- mkPopErrCtxtExprAt :: SrcSpanAnnA -> LHsExpr GhcRn -> LHsExpr GhcRn
- mkExpandedExpr :: HsExpr GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
- mkExpandedStmt :: ExprLStmt GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
- mkExpandedPatRn :: LPat GhcRn -> HsExpr GhcRn -> HsExpr GhcRn
- mkExpandedStmtAt :: SrcSpanAnnA -> ExprLStmt GhcRn -> HsExpr GhcRn -> LHsExpr GhcRn
- mkExpandedStmtPopAt :: SrcSpanAnnA -> ExprLStmt GhcRn -> HsExpr GhcRn -> LHsExpr GhcRn
- mkExpandedExprTc :: HsExpr GhcRn -> HsExpr GhcTc -> HsExpr GhcTc
- mkExpandedStmtTc :: ExprLStmt GhcRn -> HsExpr GhcTc -> HsExpr GhcTc
- isAtomicHsExpr :: forall (p :: Pass). IsPass p => HsExpr (GhcPass p) -> Bool
- isQuietHsExpr :: HsExpr id -> Bool
- pprBinds :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
- ppr_lexpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc
- ppr_apps :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))] -> SDoc
- ppr_infix_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> Maybe SDoc
- pprDebugParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc
- pprMatches :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => MatchGroup (GhcPass idR) body -> SDoc
- pprDo :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => HsDoFlavour -> [LStmt (GhcPass p) body] -> SDoc
- thTyBrackets :: SDoc -> SDoc
- ppr_with_pending_tc_splices :: SDoc -> [PendingTcSplice] -> SDoc
- ppr_infix_expr_rn :: XXExprGhcRn -> Maybe SDoc
- ppr_infix_expr_tc :: XXExprGhcTc -> Maybe SDoc
- ppr_infix_hs_expansion :: HsThingRn -> Maybe SDoc
- pprParendLExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc
- hsExprNeedsParens :: forall (p :: Pass). IsPass p => PprPrec -> HsExpr (GhcPass p) -> Bool
- gHsPar :: forall (p :: Pass). IsPass p => LHsExpr (GhcPass p) -> HsExpr (GhcPass p)
- parenthesizeHsExpr :: forall (p :: Pass). IsPass p => PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
- stripParensLHsExpr :: forall (p :: Pass). LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
- stripParensHsExpr :: forall (p :: Pass). HsExpr (GhcPass p) -> HsExpr (GhcPass p)
- type CmdSyntaxTable p = [(Name, HsExpr p)]
- data CmdTopTc = CmdTopTc Type Type (CmdSyntaxTable GhcTc)
- pprCmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc
- pprLCmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc
- isQuietHsCmd :: HsCmd id -> Bool
- ppr_cmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc
- ppr_lcmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc
- pprArrowExpr :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc
- pprCmdArg :: forall (p :: Pass). OutputableBndrId p => HsCmdTop (GhcPass p) -> SDoc
- data MatchGroupTc = MatchGroupTc {
  - mg_arg_tys :: [Scaled Type]
  - mg_res_ty :: Type
  - mg_origin :: Origin
  }
- pprMatch :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc
- isEmptyMatchGroup :: forall (p :: Pass) body. MatchGroup (GhcPass p) body -> Bool
- isSingletonMatchGroup :: forall (p :: Pass) body. [LMatch (GhcPass p) body] -> Bool
- matchGroupArity :: forall (id :: Pass) body. MatchGroup (GhcPass id) body -> Arity
- hsLMatchPats :: forall (id :: Pass) body. LMatch (GhcPass id) body -> [LPat (GhcPass id)]
- data GrhsAnn = GrhsAnn {
  - ga_vbar :: Maybe EpaLocation
  - ga_sep :: AddEpAnn
  }
- 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
  }
- pprStmt :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA, Outputable body) => StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
- pprBindStmt :: (Outputable pat, Outputable expr) => pat -> expr -> SDoc
- pprTransStmt :: Outputable body => Maybe body -> body -> TransForm -> SDoc
- ppr_do_stmts :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA, Outputable body) => [LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc
- pprTransformStmt :: forall (p :: Pass). OutputableBndrId p => [IdP (GhcPass p)] -> LHsExpr (GhcPass p) -> Maybe (LHsExpr (GhcPass p)) -> SDoc
- pprBy :: Outputable body => Maybe body -> SDoc
- ppr_module_name_prefix :: Maybe ModuleName -> SDoc
- pprComp :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc
- pprQuals :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body, Anno (StmtLR (GhcPass p) (GhcPass p) body) ~ SrcSpanAnnA) => [LStmt (GhcPass p) body] -> SDoc
- data DelayedSplice = DelayedSplice TcLclEnv (LHsExpr GhcRn) TcType (LHsExpr GhcTc)
- data UntypedSpliceFlavour
  - = UntypedExpSplice
  - | UntypedPatSplice
  - | UntypedTypeSplice
  - | UntypedDeclSplice
- pprPendingSplice :: forall (p :: Pass). OutputableBndrId p => SplicePointName -> LHsExpr (GhcPass p) -> SDoc
- ppr_splice :: forall (p :: Pass). OutputableBndrId p => SDoc -> Maybe SplicePointName -> LHsExpr (GhcPass p) -> SDoc
- ppr_quasi :: OutputableBndr p => p -> FastString -> SDoc
- thBrackets :: SDoc -> SDoc -> SDoc
- pp_dotdot :: SDoc
- type HsMatchContextPs = HsMatchContext (LIdP GhcPs)
- type HsStmtContextRn = HsStmtContext (LIdP GhcRn)
- pprExternalSrcLoc :: (StringLiteral, (Int, Int), (Int, Int)) -> SDoc
- pprHsArrType :: HsArrAppType -> SDoc
- pprStmtContext :: Outputable fn => HsStmtContext fn -> SDoc
- matchContextErrString :: Outputable fn => HsMatchContext fn -> SDoc
- matchArrowContextErrString :: HsArrowMatchContext -> SDoc
- matchDoContextErrString :: HsDoFlavour -> SDoc
- pprMatchInCtxt :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc
- pprMatchContext :: Outputable fn => HsMatchContext fn -> SDoc
- pprStmtInCtxt :: forall (idL :: Pass) (idR :: Pass) fn body. (OutputableBndrId idL, OutputableBndrId idR, Outputable fn, Outputable body, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA) => HsStmtContext fn -> StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
- pprAStmtContext :: Outputable fn => HsStmtContext fn -> SDoc
- pprMatchContextNoun :: Outputable fn => HsMatchContext fn -> SDoc
- pprArrowMatchContextNoun :: HsArrowMatchContext -> SDoc
- pprMatchContextNouns :: Outputable fn => HsMatchContext fn -> SDoc
- pprArrowMatchContextNouns :: HsArrowMatchContext -> SDoc
- pprAHsDoFlavour :: HsDoFlavour -> SDoc
- pprHsDoFlavour :: HsDoFlavour -> SDoc
- pprStmtCat :: forall (p :: Pass) body. 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 #

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

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

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

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

data HsUntypedSpliceResult thing #

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

Pending Type-checker Splice

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 #

Pending Renamer Splice

Constructors

PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr 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 #

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

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 -> LHsExpr (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 #

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

mkRnSyntaxExpr :: Name -> SyntaxExprRn #

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

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

Constructors

EpAnnHsCase |

Fields

- hsCaseAnnCase :: EpaLocation
- hsCaseAnnOf :: EpaLocation
- hsCaseAnnsRest :: [AddEpAnn]

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

Constructors

EpAnnUnboundVar |

Fields

- hsUnboundBackquotes :: (EpaLocation, EpaLocation)
- hsUnboundHole :: EpaLocation

#### Instances

Instances details

Data EpAnnUnboundVar # |

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: EpAnnUnboundVar -> Constr #

dataTypeOf :: EpAnnUnboundVar -> DataType #

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

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

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

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

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

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

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

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

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

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

data AnnExplicitSum #

Constructors

AnnExplicitSum |

Fields

- aesOpen :: EpaLocation
- aesBarsBefore :: [EpaLocation]
- aesBarsAfter :: [EpaLocation]
- 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 :: EpaLocation
- aiThen :: EpaLocation
- aiElse :: EpaLocation
- aiThenSemi :: Maybe EpaLocation
- aiElseSemi :: Maybe EpaLocation

#### 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 :: EpaLocation

  '('

- apClose :: EpaLocation

  ')'

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

Constructors

AnnFieldLabel |

Fields

- afDot :: Maybe EpaLocation

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

#### 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 !(HsWrap HsExpr) |
ExpandedThingTc |

Fields

- xtc_orig :: HsThingRn
- xtc_expanded :: HsExpr GhcTc

ConLikeTc ConLike [TcTyVar] [Scaled TcType] |
HsTick CoreTickish (LHsExpr GhcTc) |
HsBinTick Int Int (LHsExpr GhcTc) |

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

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

data GrhsAnn #

Constructors

GrhsAnn |

Fields

- ga_vbar :: Maybe EpaLocation
- ga_sep :: AddEpAnn

  Match separator location

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

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

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

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

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

thBrackets :: SDoc -> SDoc -> SDoc #

pp_dotdot :: SDoc #

type HsMatchContextPs = HsMatchContext (LIdP GhcPs) #

type HsStmtContextRn = HsStmtContext (LIdP GhcRn) #

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

pprHsArrType :: HsArrAppType -> SDoc #

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

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

matchArrowContextErrString :: HsArrowMatchContext -> SDoc #

matchDoContextErrString :: HsDoFlavour -> SDoc #

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

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

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

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

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

pprArrowMatchContextNoun :: HsArrowMatchContext -> SDoc #

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

pprArrowMatchContextNouns :: HsArrowMatchContext -> SDoc #

pprAHsDoFlavour :: HsDoFlavour -> SDoc #

pprHsDoFlavour :: HsDoFlavour -> SDoc #

pprStmtCat :: forall (p :: Pass) body. 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 idL => Outputable (ApplicativeArg (GhcPass idL)) # |
Instance details Methods ppr :: ApplicativeArg (GhcPass idL) -> 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 #