Safe Haskell	None
Language	Haskell2010

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 :: LamCaseVariant -> SDoc
data PendingTcSplice = PendingTcSplice SplicePointName (LHsExpr GhcTc)
data PendingRnSplice = PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)
type SplicePointName = Name
data DelayedSplice = DelayedSplice TcLclEnv (LHsExpr GhcRn) TcType (LHsExpr GhcTc)
newtype ThModFinalizers = ThModFinalizers [ForeignRef (Q ())]
data SyntaxExprRn
- = SyntaxExprRn (HsExpr GhcRn)
- | NoSyntaxExprRn
data SyntaxExprTc
- = SyntaxExprTc {
  - syn_expr :: HsExpr GhcTc
  - syn_arg_wraps :: [HsWrapper]
  - syn_res_wrap :: HsWrapper
  }
- | NoSyntaxExprTc
pp_rhs :: Outputable body => HsMatchContext passL -> body -> SDoc
pprTypedSplice :: forall (p :: Pass). OutputableBndrId p => Maybe SplicePointName -> LHsExpr (GhcPass p) -> 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 ...
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
}
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
data HsExpansion orig expanded = HsExpanded orig expanded
data XXExprGhcTc
- = WrapExpr !(HsWrap HsExpr)
- | ExpansionExpr !(HsExpansion (HsExpr GhcRn) (HsExpr GhcTc))
- | ConLikeTc ConLike [TcTyVar] [Scaled TcType]
- | HsTick CoreTickish (LHsExpr GhcTc)
- | HsBinTick Int Int (LHsExpr 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 :: HsExpansion (HsExpr GhcRn) (HsExpr GhcRn) -> Maybe SDoc
ppr_infix_expr_tc :: XXExprGhcTc -> 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 (id :: Pass). LHsExpr (GhcPass id) -> HsExpr (GhcPass id)
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 passL. (OutputableBndrId idR, Outputable body) => HsMatchContext passL -> GRHSs (GhcPass idR) body -> SDoc
pprGRHS :: forall (idR :: Pass) body passL. (OutputableBndrId idR, Outputable body) => HsMatchContext passL -> GRHS (GhcPass idR) body -> SDoc
matchSeparator :: HsMatchContext p -> 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 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
pprExternalSrcLoc :: (StringLiteral, (Int, Int), (Int, Int)) -> SDoc
pprHsArrType :: HsArrAppType -> SDoc
pprStmtContext :: (Outputable (IdP (NoGhcTc p)), UnXRec (NoGhcTc p)) => HsStmtContext p -> SDoc
matchContextErrString :: forall (p :: Pass). OutputableBndrId p => HsMatchContext (GhcPass p) -> SDoc
matchArrowContextErrString :: HsArrowMatchContext -> SDoc
matchDoContextErrString :: HsDoFlavour -> SDoc
pprMatchInCtxt :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc
pprMatchContext :: (Outputable (IdP (NoGhcTc p)), UnXRec (NoGhcTc p)) => HsMatchContext p -> SDoc
pprStmtInCtxt :: forall (idL :: Pass) (idR :: Pass) (ctx :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, OutputableBndrId ctx, Outputable body, Anno (StmtLR (GhcPass idL) (GhcPass idR) body) ~ SrcSpanAnnA) => HsStmtContext (GhcPass ctx) -> StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
pprAStmtContext :: (Outputable (IdP (NoGhcTc p)), UnXRec (NoGhcTc p)) => HsStmtContext p -> SDoc
pprMatchContextNoun :: (Outputable (IdP (NoGhcTc p)), UnXRec (NoGhcTc p)) => HsMatchContext p -> SDoc
pprArrowMatchContextNoun :: HsArrowMatchContext -> SDoc
pprMatchContextNouns :: (Outputable (IdP (NoGhcTc p)), UnXRec (NoGhcTc p)) => HsMatchContext p -> 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 Source #

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

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

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

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

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

data HsUntypedSpliceResult thing Source #

Constructors

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

Instances

Instances details

Data a => Data (HsUntypedSpliceResult a) Source #

Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: HsUntypedSpliceResult a -> Constr Source #

dataTypeOf :: HsUntypedSpliceResult a -> DataType Source #

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

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

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

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

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

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

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

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

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

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

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

lamCaseKeyword :: LamCaseVariant -> SDoc Source #

data PendingTcSplice Source #

Pending Type-checker Splice

Constructors

PendingTcSplice SplicePointName (LHsExpr GhcTc)

Instances

Instances details

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

data PendingRnSplice Source #

Pending Renamer Splice

Constructors

PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)

Instances

Instances details

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

type SplicePointName = Name Source #

data DelayedSplice Source #

Constructors

DelayedSplice TcLclEnv (LHsExpr GhcRn) TcType (LHsExpr GhcTc)

Instances

Instances details

Data DelayedSplice Source #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: DelayedSplice -> Constr Source #

dataTypeOf :: DelayedSplice -> DataType Source #

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

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

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

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

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

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

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

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

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

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

newtype ThModFinalizers Source #

Finalizers produced by a splice with addModFinalizer

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

Constructors

ThModFinalizers [ForeignRef (Q ())]

Instances

Instances details

Data ThModFinalizers Source #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: ThModFinalizers -> Constr Source #

dataTypeOf :: ThModFinalizers -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data SyntaxExprRn Source #

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

Constructors

SyntaxExprRn (HsExpr GhcRn)
NoSyntaxExprRn

Instances

Instances details

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

data SyntaxExprTc Source #

An expression with wrappers, used for rebindable syntax

This should desugar to

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

where the actual arguments come from elsewhere in the AST.

Constructors

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

Instances

Instances details

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

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

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

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

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

type PostTcExpr = HsExpr GhcTc Source #

Post-Type checking Expression

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

type PostTcTable = [(Name, PostTcExpr)] Source #

Post-Type checking Table

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

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

Equations

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

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

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

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

mkSyntaxExpr :: HsExpr GhcRn -> SyntaxExprRn Source #

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

mkRnSyntaxExpr :: Name -> SyntaxExprRn Source #

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

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

HsWrap appears only in typechecker output

Constructors

HsWrap HsWrapper (hs_syn GhcTc)

Instances

Instances details

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

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: HsWrap hs_syn -> Constr Source #

dataTypeOf :: HsWrap hs_syn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data HsBracketTc Source #

Constructors

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

Instances

Instances details

Data HsBracketTc Source #

Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: HsBracketTc -> Constr Source #

dataTypeOf :: HsBracketTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data EpAnnHsCase Source #

Constructors

EpAnnHsCase
Fields hsCaseAnnCase :: EpaLocation hsCaseAnnOf :: EpaLocation hsCaseAnnsRest :: [AddEpAnn]

Instances

Instances details

Data EpAnnHsCase Source #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: EpAnnHsCase -> Constr Source #

dataTypeOf :: EpAnnHsCase -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data EpAnnUnboundVar Source #

Constructors

EpAnnUnboundVar
Fields hsUnboundBackquotes :: (EpaLocation, EpaLocation) hsUnboundHole :: EpaLocation

Instances

Instances details

Data EpAnnUnboundVar Source #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: EpAnnUnboundVar -> Constr Source #

dataTypeOf :: EpAnnUnboundVar -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data AnnExplicitSum Source #

Constructors

AnnExplicitSum
Fields aesOpen :: EpaLocation aesBarsBefore :: [EpaLocation] aesBarsAfter :: [EpaLocation] aesClose :: EpaLocation

Instances

Instances details

Data AnnExplicitSum Source #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: AnnExplicitSum -> Constr Source #

dataTypeOf :: AnnExplicitSum -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data AnnsIf Source #

Constructors

AnnsIf
Fields aiIf :: EpaLocation aiThen :: EpaLocation aiElse :: EpaLocation aiThenSemi :: Maybe EpaLocation aiElseSemi :: Maybe EpaLocation

Instances

Instances details

Data AnnsIf Source #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: AnnsIf -> Constr Source #

dataTypeOf :: AnnsIf -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data family HsRecUpdParent x Source #

Information about the parent of a record update:

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

Instances

Instances details

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

data AnnProjection Source #

Constructors

AnnProjection
Fields apOpen :: EpaLocation '(' apClose :: EpaLocation ')'

Instances

Instances details

Data AnnProjection Source #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: AnnProjection -> Constr Source #

dataTypeOf :: AnnProjection -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data AnnFieldLabel Source #

Constructors

AnnFieldLabel
Fields afDot :: Maybe EpaLocation

Instances

Instances details

Data AnnFieldLabel Source #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: AnnFieldLabel -> Constr Source #

dataTypeOf :: AnnFieldLabel -> DataType Source #

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

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

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

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

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

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

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

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

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

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

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

data HsExpansion orig expanded Source #

Constructors

HsExpanded orig expanded

Instances

Instances details

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

data XXExprGhcTc Source #

Constructors

WrapExpr !(HsWrap HsExpr)
ExpansionExpr !(HsExpansion (HsExpr GhcRn) (HsExpr GhcTc))
ConLikeTc ConLike [TcTyVar] [Scaled TcType]
HsTick CoreTickish (LHsExpr GhcTc)
HsBinTick Int Int (LHsExpr GhcTc)

Instances

Instances details

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

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

isQuietHsExpr :: HsExpr id -> Bool Source #

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

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

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

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

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

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

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

thTyBrackets :: SDoc -> SDoc Source #

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

ppr_infix_expr_rn :: HsExpansion (HsExpr GhcRn) (HsExpr GhcRn) -> Maybe SDoc Source #

ppr_infix_expr_tc :: XXExprGhcTc -> Maybe SDoc Source #

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

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

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

gHsPar :: forall (id :: Pass). LHsExpr (GhcPass id) -> HsExpr (GhcPass id) Source #

Parenthesize an expression without token information

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

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

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

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

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

Command Syntax Table (for Arrow syntax)

data CmdTopTc Source #

Constructors

CmdTopTc Type Type (CmdSyntaxTable GhcTc)

Instances

Instances details

Data CmdTopTc Source #

Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: CmdTopTc -> Constr Source #

dataTypeOf :: CmdTopTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

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

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

isQuietHsCmd :: HsCmd id -> Bool Source #

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

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

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

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

data MatchGroupTc Source #

Constructors

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

Instances

Instances details

Data MatchGroupTc Source #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: MatchGroupTc -> Constr Source #

dataTypeOf :: MatchGroupTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

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

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

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

Is there only one RHS in this list of matches?

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

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

data GrhsAnn Source #

Constructors

GrhsAnn
Fields ga_vbar :: Maybe EpaLocation ga_sep :: AddEpAnn Match separator location

Instances

Instances details

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

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

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

matchSeparator :: HsMatchContext p -> SDoc Source #

data RecStmtTc Source #

Constructors

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

Instances

Instances details

Data RecStmtTc Source #

Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: RecStmtTc -> Constr Source #

dataTypeOf :: RecStmtTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data XBindStmtRn Source #

Constructors

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

Instances

Instances details

Data XBindStmtRn Source #

Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: XBindStmtRn -> Constr Source #

dataTypeOf :: XBindStmtRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data XBindStmtTc Source #

Constructors

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

Instances

Instances details

Data XBindStmtTc Source #

Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: XBindStmtTc -> Constr Source #

dataTypeOf :: XBindStmtTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ppr_module_name_prefix :: Maybe ModuleName -> SDoc Source #

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

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

data UntypedSpliceFlavour Source #

Constructors

UntypedExpSplice
UntypedPatSplice
UntypedTypeSplice
UntypedDeclSplice

Instances

Instances details

Data UntypedSpliceFlavour Source #

Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: UntypedSpliceFlavour -> Constr Source #

dataTypeOf :: UntypedSpliceFlavour -> DataType Source #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pp_dotdot :: SDoc Source #

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

pprHsArrType :: HsArrAppType -> SDoc Source #

pprStmtContext :: (Outputable (IdP (NoGhcTc p)), UnXRec (NoGhcTc p)) => HsStmtContext p -> SDoc Source #

matchContextErrString :: forall (p :: Pass). OutputableBndrId p => HsMatchContext (GhcPass p) -> SDoc Source #

matchArrowContextErrString :: HsArrowMatchContext -> SDoc Source #

matchDoContextErrString :: HsDoFlavour -> SDoc Source #

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

pprMatchContext :: (Outputable (IdP (NoGhcTc p)), UnXRec (NoGhcTc p)) => HsMatchContext p -> SDoc Source #

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

pprAStmtContext :: (Outputable (IdP (NoGhcTc p)), UnXRec (NoGhcTc p)) => HsStmtContext p -> SDoc Source #

pprMatchContextNoun :: (Outputable (IdP (NoGhcTc p)), UnXRec (NoGhcTc p)) => HsMatchContext p -> SDoc Source #

pprArrowMatchContextNoun :: HsArrowMatchContext -> SDoc Source #

pprMatchContextNouns :: (Outputable (IdP (NoGhcTc p)), UnXRec (NoGhcTc p)) => HsMatchContext p -> SDoc Source #

pprArrowMatchContextNouns :: HsArrowMatchContext -> SDoc Source #

pprAHsDoFlavour :: HsDoFlavour -> SDoc Source #

pprHsDoFlavour :: HsDoFlavour -> SDoc Source #

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

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

pprPrefixFastString :: FastString -> SDoc Source #

Orphan instances

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