ghc-9.0.0.20200925: The GHC API
Safe HaskellNone
LanguageHaskell2010

GHC.Hs.Expr

Description

Abstract Haskell syntax for expressions.

Synopsis

Expressions proper

type LHsExpr p Source #

Arguments

 = Located (HsExpr p)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Expression

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

Syntax Expression

SyntaxExpr is represents the function used in interpreting rebindable syntax. In the parser, we have no information to supply; in the renamer, we have the name of the function (but see Note [Monad fail : Rebindable syntax, overloaded strings] for a wrinkle) and in the type-checker we have a more elaborate structure SyntaxExprTc.

In some contexts, rebindable syntax is not implemented, and so we have constructors to represent that possibility in both the renamer and typechecker instantiations.

E.g. (>>=) is filled in before the renamer by the appropriate Name for (>>=), and then instantiated by the type checker with its type args etc

Instances

Instances details
type SyntaxExpr (GhcPass p) # 
Instance details

Defined in GHC.Hs.Expr

data SyntaxExprRn Source #

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

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

Defined in GHC.Hs.Expr

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.

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

Defined in GHC.Hs.Expr

noExpr :: HsExpr (GhcPass p) Source #

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

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

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

Command Syntax Table (for Arrow syntax)

data HsExpr p Source #

A Haskell expression.

Constructors

HsVar (XVar p) (Located (IdP p))

Variable

HsUnboundVar (XUnboundVar p) OccName

Unbound variable; also used for "holes" (_ or _x). Turned from HsVar to HsUnboundVar by the renamer, when it finds an out-of-scope variable or hole. Turned into HsVar by type checker, to support deferred type errors.

HsConLikeOut (XConLikeOut p) ConLike

After typechecker only; must be different HsVar for pretty printing

HsRecFld (XRecFld p) (AmbiguousFieldOcc p)

Variable pointing to record selector Not in use after typechecking

HsOverLabel (XOverLabel p) (Maybe (IdP p)) FastString

Overloaded label (Note [Overloaded labels] in GHC.OverloadedLabels) Just id means RebindableSyntax is in use, and gives the id of the in-scope fromLabel. NB: Not in use after typechecking

HsIPVar (XIPVar p) HsIPName

Implicit parameter (not in use after typechecking)

HsOverLit (XOverLitE p) (HsOverLit p)

Overloaded literals

HsLit (XLitE p) (HsLit p)

Simple (non-overloaded) literals

HsLam (XLam p) (MatchGroup p (LHsExpr p))

Lambda abstraction. Currently always a single match

HsLamCase (XLamCase p) (MatchGroup p (LHsExpr p))

Lambda-case

HsApp (XApp p) (LHsExpr p) (LHsExpr p)

Application

HsAppType (XAppTypeE p) (LHsExpr p) (LHsWcType (NoGhcTc p))

Visible type application

Explicit type argument; e.g f @Int x y NB: Has wildcards, but no implicit quantification

OpApp (XOpApp p) (LHsExpr p) (LHsExpr p) (LHsExpr p)

Operator applications: NB Bracketed ops such as (+) come out as Vars.

NegApp (XNegApp p) (LHsExpr p) (SyntaxExpr p)

Negation operator. Contains the negated expression and the name of negate

HsPar

Fields

  • (XPar p)
     
  • (LHsExpr p)

    Parenthesised expr; see Note [Parens in HsSyn]

SectionL (XSectionL p) (LHsExpr p) (LHsExpr p) 
SectionR (XSectionR p) (LHsExpr p) (LHsExpr p) 
ExplicitTuple (XExplicitTuple p) [LHsTupArg p] Boxity

Used for explicit tuples and sections thereof

ExplicitSum (XExplicitSum p) ConTag Arity (LHsExpr p)

Used for unboxed sum types

There will be multiple AnnVbar, (1 - alternative) before the expression, (arity - alternative) after it

HsCase (XCase p) (LHsExpr p) (MatchGroup p (LHsExpr p))
HsIf (XIf p) (LHsExpr p) (LHsExpr p) (LHsExpr p)
HsMultiIf (XMultiIf p) [LGRHS p (LHsExpr p)]

Multi-way if

HsLet (XLet p) (LHsLocalBinds p) (LHsExpr p)

let(rec)

HsDo (XDo p) (HsStmtContext GhcRn) (Located [ExprLStmt p])
ExplicitList (XExplicitList p) (Maybe (SyntaxExpr p)) [LHsExpr p]

Syntactic list: [a,b,c,...]

RecordCon

Record construction

RecordUpd

Record update

ExprWithTySig (XExprWithTySig p) (LHsExpr p) (LHsSigWcType (NoGhcTc p))

Expression with an explicit type signature. e :: type

ArithSeq (XArithSeq p) (Maybe (SyntaxExpr p)) (ArithSeqInfo p)

Arithmetic sequence

HsBracket (XBracket p) (HsBracket p)
HsRnBracketOut (XRnBracketOut p) (HsBracket GhcRn) [PendingRnSplice] 
HsTcBracketOut (XTcBracketOut p) (Maybe QuoteWrapper) (HsBracket GhcRn) [PendingTcSplice] 
HsSpliceE (XSpliceE p) (HsSplice p)
HsProc (XProc p) (LPat p) (LHsCmdTop p)

proc notation for Arrows

HsStatic (XStatic p) (LHsExpr p)
HsTick (XTick p) (Tickish (IdP p)) (LHsExpr p) 
HsBinTick (XBinTick p) Int Int (LHsExpr p) 
HsPragE (XPragE p) (HsPragE p) (LHsExpr p) 
XExpr !(XXExpr p) 

Instances

Instances details
Data (HsExpr 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) -> HsExpr GhcTc -> c (HsExpr GhcTc) Source #

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

toConstr :: HsExpr GhcTc -> Constr Source #

dataTypeOf :: HsExpr GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsExpr 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) -> HsExpr GhcRn -> c (HsExpr GhcRn) Source #

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

toConstr :: HsExpr GhcRn -> Constr Source #

dataTypeOf :: HsExpr GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsExpr 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) -> HsExpr GhcPs -> c (HsExpr GhcPs) Source #

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

toConstr :: HsExpr GhcPs -> Constr Source #

dataTypeOf :: HsExpr GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

OutputableBndrId p => Outputable (HsExpr (GhcPass p)) # 
Instance details

Defined in GHC.Hs.Expr

DisambECP (HsExpr GhcPs) # 
Instance details

Defined in GHC.Parser.PostProcess

Associated Types

type Body (HsExpr GhcPs) :: Type -> Type Source #

type InfixOp (HsExpr GhcPs) Source #

type FunArg (HsExpr GhcPs) Source #

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (HsExpr GhcPs)) Source #

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (HsExpr GhcPs)) Source #

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (HsExpr GhcPs)) -> PV (Located (HsExpr GhcPs)) Source #

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

superInfixOp :: (DisambInfixOp (InfixOp (HsExpr GhcPs)) => PV (Located (HsExpr GhcPs))) -> PV (Located (HsExpr GhcPs)) Source #

mkHsOpAppPV :: SrcSpan -> Located (HsExpr GhcPs) -> Located (InfixOp (HsExpr GhcPs)) -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (HsExpr GhcPs)) -> PV (Located (HsExpr GhcPs)) Source #

mkHsLamCasePV :: SrcSpan -> MatchGroup GhcPs (Located (HsExpr GhcPs)) -> PV (Located (HsExpr GhcPs)) Source #

superFunArg :: (DisambECP (FunArg (HsExpr GhcPs)) => PV (Located (HsExpr GhcPs))) -> PV (Located (HsExpr GhcPs)) Source #

mkHsAppPV :: SrcSpan -> Located (HsExpr GhcPs) -> Located (FunArg (HsExpr GhcPs)) -> PV (Located (HsExpr GhcPs)) Source #

mkHsAppTypePV :: SrcSpan -> Located (HsExpr GhcPs) -> LHsType GhcPs -> PV (Located (HsExpr GhcPs)) Source #

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (HsExpr GhcPs) -> Bool -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> Located [LStmt GhcPs (Located (HsExpr GhcPs))] -> PV (Located (HsExpr GhcPs)) Source #

mkHsParPV :: SrcSpan -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkHsVarPV :: Located RdrName -> PV (Located (HsExpr GhcPs)) Source #

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkHsWildCardPV :: SrcSpan -> PV (Located (HsExpr GhcPs)) Source #

mkHsTySigPV :: SrcSpan -> Located (HsExpr GhcPs) -> LHsType GhcPs -> PV (Located (HsExpr GhcPs)) Source #

mkHsExplicitListPV :: SrcSpan -> [Located (HsExpr GhcPs)] -> PV (Located (HsExpr GhcPs)) Source #

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (HsExpr GhcPs) -> ([LHsRecField GhcPs (Located (HsExpr GhcPs))], Maybe SrcSpan) -> PV (Located (HsExpr GhcPs)) Source #

mkHsNegAppPV :: SrcSpan -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (HsExpr GhcPs)) -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkHsLazyPatPV :: SrcSpan -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkHsBangPatPV :: SrcSpan -> Located (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) Source #

rejectPragmaPV :: Located (HsExpr GhcPs) -> PV () Source #

DisambInfixOp (HsExpr GhcPs) # 
Instance details

Defined in GHC.Parser.PostProcess

type Body (HsExpr GhcPs) # 
Instance details

Defined in GHC.Parser.PostProcess

type InfixOp (HsExpr GhcPs) # 
Instance details

Defined in GHC.Parser.PostProcess

type FunArg (HsExpr GhcPs) # 
Instance details

Defined in GHC.Parser.PostProcess

data RecordConTc Source #

Extra data fields for a RecordCon, added by the type checker

Instances

Instances details
Data RecordConTc # 
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) -> RecordConTc -> c RecordConTc Source #

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

toConstr :: RecordConTc -> Constr Source #

dataTypeOf :: RecordConTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data RecordUpdTc Source #

Extra data fields for a RecordUpd, added by the type checker

Instances

Instances details
Data RecordUpdTc # 
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) -> RecordUpdTc -> c RecordUpdTc Source #

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

toConstr :: RecordUpdTc -> Constr Source #

dataTypeOf :: RecordUpdTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data HsWrap hs_syn Source #

HsWrap appears only in typechecker output Invariant: The contained Expr is *NOT* itself an HsWrap. See Note [Detecting forced eta expansion] in GHC.HsToCore.Expr. This invariant is maintained by mkHsWrap. hs_syn is something like HsExpr or HsCmd

Constructors

HsWrap HsWrapper (hs_syn GhcTc) 

Instances

Instances details
(Data (hs_syn GhcTc), Typeable hs_syn) => Data (HsWrap hs_syn) # 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: HsWrap hs_syn -> Constr Source #

dataTypeOf :: HsWrap hs_syn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data XXExprGhcTc Source #

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

data HsExpansion a b Source #

Constructors

HsExpanded a b 

Instances

Instances details
(Data a, Data b) => Data (HsExpansion a b) # 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: HsExpansion a b -> Constr Source #

dataTypeOf :: HsExpansion a b -> DataType Source #

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

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

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

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

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

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

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

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

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

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

(Outputable a, Outputable b) => Outputable (HsExpansion a b) #

Just print the original expression (the a).

Instance details

Defined in GHC.Hs.Expr

mkExpanded Source #

Arguments

:: (HsExpansion a b -> b)

XExpr, XCmd, ...

-> a

source expression (GhcPass)

-> b

"desugared" expression (GhcPass)

-> b

suitably wrapped HsExpansion

Build a "wrapped" HsExpansion out of an extension constructor, and the two components of the expansion: original and desugared expressions.

See Note [Rebindable Syntax and HsExpansion] above for more details.

data HsPragE p Source #

A pragma, written as {--}, that may appear within an expression.

Instances

Instances details
Data (HsPragE 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) -> HsPragE GhcTc -> c (HsPragE GhcTc) Source #

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

toConstr :: HsPragE GhcTc -> Constr Source #

dataTypeOf :: HsPragE GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsPragE 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) -> HsPragE GhcRn -> c (HsPragE GhcRn) Source #

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

toConstr :: HsPragE GhcRn -> Constr Source #

dataTypeOf :: HsPragE GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsPragE 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) -> HsPragE GhcPs -> c (HsPragE GhcPs) Source #

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

toConstr :: HsPragE GhcPs -> Constr Source #

dataTypeOf :: HsPragE GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Outputable (HsPragE (GhcPass p)) # 
Instance details

Defined in GHC.Hs.Expr

type LHsTupArg id = Located (HsTupArg id) Source #

Located Haskell Tuple Argument

HsTupArg is used for tuple sections (,a,) is represented by ExplicitTuple [Missing ty1, Present a, Missing ty3] Which in turn stands for (x:ty1 y:ty2. (x,a,y))

data HsTupArg id Source #

Haskell Tuple Argument

Constructors

Present (XPresent id) (LHsExpr id)

The argument

Missing (XMissing id)

The argument is missing, but this is its type

XTupArg !(XXTupArg id)

Note [Trees that Grow] extension point

Instances

Instances details
Data (HsTupArg 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) -> HsTupArg GhcTc -> c (HsTupArg GhcTc) Source #

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

toConstr :: HsTupArg GhcTc -> Constr Source #

dataTypeOf :: HsTupArg GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsTupArg 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) -> HsTupArg GhcRn -> c (HsTupArg GhcRn) Source #

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

toConstr :: HsTupArg GhcRn -> Constr Source #

dataTypeOf :: HsTupArg GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsTupArg 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) -> HsTupArg GhcPs -> c (HsTupArg GhcPs) Source #

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

toConstr :: HsTupArg GhcPs -> Constr Source #

dataTypeOf :: HsTupArg GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

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

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

parenthesizeHsExpr :: 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.

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

type LHsCmd id = Located (HsCmd id) Source #

Located Haskell Command (for arrow syntax)

data HsCmd id Source #

Haskell Command (e.g. a "statement" in an Arrow proc block)

Instances

Instances details
Data (HsCmd 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) -> HsCmd GhcTc -> c (HsCmd GhcTc) Source #

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

toConstr :: HsCmd GhcTc -> Constr Source #

dataTypeOf :: HsCmd GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsCmd 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) -> HsCmd GhcRn -> c (HsCmd GhcRn) Source #

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

toConstr :: HsCmd GhcRn -> Constr Source #

dataTypeOf :: HsCmd GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsCmd 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) -> HsCmd GhcPs -> c (HsCmd GhcPs) Source #

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

toConstr :: HsCmd GhcPs -> Constr Source #

dataTypeOf :: HsCmd GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

OutputableBndrId p => Outputable (HsCmd (GhcPass p)) # 
Instance details

Defined in GHC.Hs.Expr

DisambECP (HsCmd GhcPs) # 
Instance details

Defined in GHC.Parser.PostProcess

Associated Types

type Body (HsCmd GhcPs) :: Type -> Type Source #

type InfixOp (HsCmd GhcPs) Source #

type FunArg (HsCmd GhcPs) Source #

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (HsCmd GhcPs)) Source #

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (HsCmd GhcPs)) Source #

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (HsCmd GhcPs)) -> PV (Located (HsCmd GhcPs)) Source #

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

superInfixOp :: (DisambInfixOp (InfixOp (HsCmd GhcPs)) => PV (Located (HsCmd GhcPs))) -> PV (Located (HsCmd GhcPs)) Source #

mkHsOpAppPV :: SrcSpan -> Located (HsCmd GhcPs) -> Located (InfixOp (HsCmd GhcPs)) -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (HsCmd GhcPs)) -> PV (Located (HsCmd GhcPs)) Source #

mkHsLamCasePV :: SrcSpan -> MatchGroup GhcPs (Located (HsCmd GhcPs)) -> PV (Located (HsCmd GhcPs)) Source #

superFunArg :: (DisambECP (FunArg (HsCmd GhcPs)) => PV (Located (HsCmd GhcPs))) -> PV (Located (HsCmd GhcPs)) Source #

mkHsAppPV :: SrcSpan -> Located (HsCmd GhcPs) -> Located (FunArg (HsCmd GhcPs)) -> PV (Located (HsCmd GhcPs)) Source #

mkHsAppTypePV :: SrcSpan -> Located (HsCmd GhcPs) -> LHsType GhcPs -> PV (Located (HsCmd GhcPs)) Source #

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (HsCmd GhcPs) -> Bool -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkHsDoPV :: SrcSpan -> Maybe ModuleName -> Located [LStmt GhcPs (Located (HsCmd GhcPs))] -> PV (Located (HsCmd GhcPs)) Source #

mkHsParPV :: SrcSpan -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkHsVarPV :: Located RdrName -> PV (Located (HsCmd GhcPs)) Source #

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkHsWildCardPV :: SrcSpan -> PV (Located (HsCmd GhcPs)) Source #

mkHsTySigPV :: SrcSpan -> Located (HsCmd GhcPs) -> LHsType GhcPs -> PV (Located (HsCmd GhcPs)) Source #

mkHsExplicitListPV :: SrcSpan -> [Located (HsCmd GhcPs)] -> PV (Located (HsCmd GhcPs)) Source #

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (HsCmd GhcPs) -> ([LHsRecField GhcPs (Located (HsCmd GhcPs))], Maybe SrcSpan) -> PV (Located (HsCmd GhcPs)) Source #

mkHsNegAppPV :: SrcSpan -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (HsCmd GhcPs)) -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkHsLazyPatPV :: SrcSpan -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkHsBangPatPV :: SrcSpan -> Located (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) Source #

rejectPragmaPV :: Located (HsCmd GhcPs) -> PV () Source #

type Body (HsCmd GhcPs) # 
Instance details

Defined in GHC.Parser.PostProcess

type InfixOp (HsCmd GhcPs) # 
Instance details

Defined in GHC.Parser.PostProcess

type FunArg (HsCmd GhcPs) # 
Instance details

Defined in GHC.Parser.PostProcess

data HsArrAppType Source #

Haskell Array Application Type

Instances

Instances details
Data HsArrAppType # 
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) -> HsArrAppType -> c HsArrAppType Source #

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

toConstr :: HsArrAppType -> Constr Source #

dataTypeOf :: HsArrAppType -> DataType Source #

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

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

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

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

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

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

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

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

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

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

type LHsCmdTop p = Located (HsCmdTop p) Source #

Top-level command, introducing a new arrow. This may occur inside a proc (where the stack is empty) or as an argument of a command-forming operator.

Located Haskell Top-level Command

data HsCmdTop p Source #

Haskell Top-level Command

Constructors

HsCmdTop (XCmdTop p) (LHsCmd p) 
XCmdTop !(XXCmdTop p) 

Instances

Instances details
Data (HsCmdTop 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) -> HsCmdTop GhcTc -> c (HsCmdTop GhcTc) Source #

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

toConstr :: HsCmdTop GhcTc -> Constr Source #

dataTypeOf :: HsCmdTop GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsCmdTop 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) -> HsCmdTop GhcRn -> c (HsCmdTop GhcRn) Source #

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

toConstr :: HsCmdTop GhcRn -> Constr Source #

dataTypeOf :: HsCmdTop GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsCmdTop 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) -> HsCmdTop GhcPs -> c (HsCmdTop GhcPs) Source #

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

toConstr :: HsCmdTop GhcPs -> Constr Source #

dataTypeOf :: HsCmdTop GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

OutputableBndrId p => Outputable (HsCmdTop (GhcPass p)) # 
Instance details

Defined in GHC.Hs.Expr

data CmdTopTc Source #

Instances

Instances details
Data CmdTopTc # 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: CmdTopTc -> Constr Source #

dataTypeOf :: CmdTopTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

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

type HsRecordBinds p = HsRecFields p (LHsExpr p) Source #

Haskell Record Bindings

data MatchGroup p body Source #

Constructors

MG 

Fields

XMatchGroup !(XXMatchGroup p body) 

Instances

Instances details
Data body => Data (MatchGroup GhcTc body) # 
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) -> MatchGroup GhcTc body -> c (MatchGroup GhcTc body) Source #

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

toConstr :: MatchGroup GhcTc body -> Constr Source #

dataTypeOf :: MatchGroup GhcTc body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> MatchGroup GhcTc body -> MatchGroup GhcTc body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcTc body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcTc body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroup GhcTc body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MatchGroup GhcTc body -> m (MatchGroup GhcTc body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcTc body -> m (MatchGroup GhcTc body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcTc body -> m (MatchGroup GhcTc body) Source #

Data body => Data (MatchGroup GhcRn body) # 
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) -> MatchGroup GhcRn body -> c (MatchGroup GhcRn body) Source #

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

toConstr :: MatchGroup GhcRn body -> Constr Source #

dataTypeOf :: MatchGroup GhcRn body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> MatchGroup GhcRn body -> MatchGroup GhcRn body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcRn body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcRn body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroup GhcRn body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MatchGroup GhcRn body -> m (MatchGroup GhcRn body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcRn body -> m (MatchGroup GhcRn body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcRn body -> m (MatchGroup GhcRn body) Source #

Data body => Data (MatchGroup GhcPs body) # 
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) -> MatchGroup GhcPs body -> c (MatchGroup GhcPs body) Source #

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

toConstr :: MatchGroup GhcPs body -> Constr Source #

dataTypeOf :: MatchGroup GhcPs body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> MatchGroup GhcPs body -> MatchGroup GhcPs body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcPs body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup GhcPs body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroup GhcPs body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MatchGroup GhcPs body -> m (MatchGroup GhcPs body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcPs body -> m (MatchGroup GhcPs body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup GhcPs body -> m (MatchGroup GhcPs body) Source #

data MatchGroupTc Source #

Constructors

MatchGroupTc 

Instances

Instances details
Data MatchGroupTc # 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: MatchGroupTc -> Constr Source #

dataTypeOf :: MatchGroupTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

type LMatch id body = Located (Match id body) Source #

Located Match

May have AnnKeywordId : AnnSemi when in a list

data Match p body Source #

Constructors

Match 

Fields

XMatch !(XXMatch p body) 

Instances

Instances details
Data body => Data (Match GhcTc body) # 
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) -> Match GhcTc body -> c (Match GhcTc body) Source #

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

toConstr :: Match GhcTc body -> Constr Source #

dataTypeOf :: Match GhcTc body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> Match GhcTc body -> Match GhcTc body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcTc body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcTc body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match GhcTc body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match GhcTc body -> m (Match GhcTc body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcTc body -> m (Match GhcTc body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcTc body -> m (Match GhcTc body) Source #

Data body => Data (Match GhcRn body) # 
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) -> Match GhcRn body -> c (Match GhcRn body) Source #

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

toConstr :: Match GhcRn body -> Constr Source #

dataTypeOf :: Match GhcRn body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> Match GhcRn body -> Match GhcRn body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcRn body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcRn body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match GhcRn body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match GhcRn body -> m (Match GhcRn body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcRn body -> m (Match GhcRn body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcRn body -> m (Match GhcRn body) Source #

Data body => Data (Match GhcPs body) # 
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) -> Match GhcPs body -> c (Match GhcPs body) Source #

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

toConstr :: Match GhcPs body -> Constr Source #

dataTypeOf :: Match GhcPs body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> Match GhcPs body -> Match GhcPs body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcPs body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match GhcPs body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match GhcPs body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match GhcPs body -> m (Match GhcPs body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcPs body -> m (Match GhcPs body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match GhcPs body -> m (Match GhcPs body) Source #

(OutputableBndrId pr, Outputable body) => Outputable (Match (GhcPass pr) body) # 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: Match (GhcPass pr) body -> SDoc Source #

pprPrec :: Rational -> Match (GhcPass pr) body -> SDoc Source #

isSingletonMatchGroup :: [LMatch id body] -> Bool Source #

Is there only one RHS in this list of matches?

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

data GRHSs p body Source #

Guarded Right-Hand Sides

GRHSs are used both for pattern bindings and for Matches

Constructors

GRHSs 

Fields

XGRHSs !(XXGRHSs p body) 

Instances

Instances details
Data body => Data (GRHSs GhcTc body) # 
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) -> GRHSs GhcTc body -> c (GRHSs GhcTc body) Source #

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

toConstr :: GRHSs GhcTc body -> Constr Source #

dataTypeOf :: GRHSs GhcTc body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> GRHSs GhcTc body -> GRHSs GhcTc body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcTc body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcTc body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHSs GhcTc body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHSs GhcTc body -> m (GRHSs GhcTc body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcTc body -> m (GRHSs GhcTc body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcTc body -> m (GRHSs GhcTc body) Source #

Data body => Data (GRHSs GhcRn body) # 
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) -> GRHSs GhcRn body -> c (GRHSs GhcRn body) Source #

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

toConstr :: GRHSs GhcRn body -> Constr Source #

dataTypeOf :: GRHSs GhcRn body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> GRHSs GhcRn body -> GRHSs GhcRn body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcRn body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcRn body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHSs GhcRn body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHSs GhcRn body -> m (GRHSs GhcRn body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcRn body -> m (GRHSs GhcRn body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcRn body -> m (GRHSs GhcRn body) Source #

Data body => Data (GRHSs GhcPs body) # 
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) -> GRHSs GhcPs body -> c (GRHSs GhcPs body) Source #

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

toConstr :: GRHSs GhcPs body -> Constr Source #

dataTypeOf :: GRHSs GhcPs body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> GRHSs GhcPs body -> GRHSs GhcPs body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcPs body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs GhcPs body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHSs GhcPs body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHSs GhcPs body -> m (GRHSs GhcPs body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcPs body -> m (GRHSs GhcPs body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs GhcPs body -> m (GRHSs GhcPs body) Source #

type LGRHS id body = Located (GRHS id body) Source #

Located Guarded Right-Hand Side

data GRHS p body Source #

Guarded Right Hand Side.

Constructors

GRHS (XCGRHS p body) [GuardLStmt p] body 
XGRHS !(XXGRHS p body) 

Instances

Instances details
Data body => Data (GRHS GhcTc body) # 
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) -> GRHS GhcTc body -> c (GRHS GhcTc body) Source #

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

toConstr :: GRHS GhcTc body -> Constr Source #

dataTypeOf :: GRHS GhcTc body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> GRHS GhcTc body -> GRHS GhcTc body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcTc body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcTc body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHS GhcTc body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHS GhcTc body -> m (GRHS GhcTc body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcTc body -> m (GRHS GhcTc body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcTc body -> m (GRHS GhcTc body) Source #

Data body => Data (GRHS GhcRn body) # 
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) -> GRHS GhcRn body -> c (GRHS GhcRn body) Source #

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

toConstr :: GRHS GhcRn body -> Constr Source #

dataTypeOf :: GRHS GhcRn body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> GRHS GhcRn body -> GRHS GhcRn body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcRn body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcRn body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHS GhcRn body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHS GhcRn body -> m (GRHS GhcRn body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcRn body -> m (GRHS GhcRn body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcRn body -> m (GRHS GhcRn body) Source #

Data body => Data (GRHS GhcPs body) # 
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) -> GRHS GhcPs body -> c (GRHS GhcPs body) Source #

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

toConstr :: GRHS GhcPs body -> Constr Source #

dataTypeOf :: GRHS GhcPs body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> GRHS GhcPs body -> GRHS GhcPs body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcPs body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHS GhcPs body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHS GhcPs body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHS GhcPs body -> m (GRHS GhcPs body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcPs body -> m (GRHS GhcPs body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS GhcPs body -> m (GRHS GhcPs body) Source #

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

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

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

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

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

type LStmt id body = Located (StmtLR id id body) Source #

Located do block Statement

type LStmtLR idL idR body = Located (StmtLR idL idR body) Source #

Located Statement with separate Left and Right id's

type Stmt id body = StmtLR id id body Source #

do block Statement

type CmdLStmt id = LStmt id (LHsCmd id) Source #

Command Located Statement

type CmdStmt id = Stmt id (LHsCmd id) Source #

Command Statement

type ExprLStmt id = LStmt id (LHsExpr id) Source #

Expression Located Statement

type ExprStmt id = Stmt id (LHsExpr id) Source #

Expression Statement

type GuardLStmt id = LStmt id (LHsExpr id) Source #

Guard Located Statement

type GuardStmt id = Stmt id (LHsExpr id) Source #

Guard Statement

type GhciLStmt id = LStmt id (LHsExpr id) Source #

Ghci Located Statement

type GhciStmt id = Stmt id (LHsExpr id) Source #

Ghci Statement

data StmtLR idL idR body Source #

API Annotations when in qualifier lists or guards - AnnKeywordId : AnnVbar, AnnComma,AnnThen, AnnBy,AnnBy, AnnGroup,AnnUsing

Constructors

LastStmt (XLastStmt idL idR body) body (Maybe Bool) (SyntaxExpr idR) 
BindStmt 

Fields

  • (XBindStmt idL idR body)

    Post renaming has optional fail and bind / (>>=) operator. Post typechecking, also has multiplicity of the argument and the result type of the function passed to bind; that is, (P, S) in (>>=) :: Q -> (R # P -> S) -> T See Note [The type of bind in Stmts]

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

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

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

BodyStmt (XBodyStmt idL idR body) body (SyntaxExpr idR) (SyntaxExpr idR) 
LetStmt (XLetStmt idL idR body) (LHsLocalBindsLR idL idR)
ParStmt (XParStmt idL idR body) [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR) 
TransStmt 

Fields

RecStmt

Fields

XStmtLR !(XXStmtLR idL idR body) 

Instances

Instances details
Data body => Data (StmtLR GhcTc GhcTc body) # 
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) -> StmtLR GhcTc GhcTc body -> c (StmtLR GhcTc GhcTc body) Source #

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

toConstr :: StmtLR GhcTc GhcTc body -> Constr Source #

dataTypeOf :: StmtLR GhcTc GhcTc body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcTc GhcTc body -> StmtLR GhcTc GhcTc body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcTc GhcTc body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcTc GhcTc body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcTc GhcTc body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcTc GhcTc body -> m (StmtLR GhcTc GhcTc body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcTc GhcTc body -> m (StmtLR GhcTc GhcTc body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcTc GhcTc body -> m (StmtLR GhcTc GhcTc body) Source #

Data body => Data (StmtLR GhcRn GhcRn body) # 
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) -> StmtLR GhcRn GhcRn body -> c (StmtLR GhcRn GhcRn body) Source #

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

toConstr :: StmtLR GhcRn GhcRn body -> Constr Source #

dataTypeOf :: StmtLR GhcRn GhcRn body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcRn GhcRn body -> StmtLR GhcRn GhcRn body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcRn GhcRn body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcRn GhcRn body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcRn GhcRn body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcRn GhcRn body -> m (StmtLR GhcRn GhcRn body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcRn GhcRn body -> m (StmtLR GhcRn GhcRn body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcRn GhcRn body -> m (StmtLR GhcRn GhcRn body) Source #

Data body => Data (StmtLR GhcPs GhcRn body) # 
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) -> StmtLR GhcPs GhcRn body -> c (StmtLR GhcPs GhcRn body) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StmtLR GhcPs GhcRn body) Source #

toConstr :: StmtLR GhcPs GhcRn body -> Constr Source #

dataTypeOf :: StmtLR GhcPs GhcRn body -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StmtLR GhcPs GhcRn body)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StmtLR GhcPs GhcRn body)) Source #

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcPs GhcRn body -> StmtLR GhcPs GhcRn body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcRn body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcRn body -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> StmtLR GhcPs GhcRn body -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcPs GhcRn body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcRn body -> m (StmtLR GhcPs GhcRn body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcRn body -> m (StmtLR GhcPs GhcRn body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcRn body -> m (StmtLR GhcPs GhcRn body) Source #

Data body => Data (StmtLR GhcPs GhcPs body) # 
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) -> StmtLR GhcPs GhcPs body -> c (StmtLR GhcPs GhcPs body) Source #

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

toConstr :: StmtLR GhcPs GhcPs body -> Constr Source #

dataTypeOf :: StmtLR GhcPs GhcPs body -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> StmtLR GhcPs GhcPs body -> StmtLR GhcPs GhcPs body Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcPs body -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR GhcPs GhcPs body -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR GhcPs GhcPs body -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcPs body -> m (StmtLR GhcPs GhcPs body) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcPs body -> m (StmtLR GhcPs GhcPs body) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR GhcPs GhcPs body -> m (StmtLR GhcPs GhcPs body) Source #

(OutputableBndrId pl, OutputableBndrId pr, Outputable body) => Outputable (StmtLR (GhcPass pl) (GhcPass pr) body) # 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc Source #

pprPrec :: Rational -> StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc Source #

data RecStmtTc Source #

Instances

Instances details
Data RecStmtTc # 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: RecStmtTc -> Constr Source #

dataTypeOf :: RecStmtTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data XBindStmtRn Source #

Instances

Instances details
Data XBindStmtRn # 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: XBindStmtRn -> Constr Source #

dataTypeOf :: XBindStmtRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data XBindStmtTc Source #

Instances

Instances details
Data XBindStmtTc # 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: XBindStmtTc -> Constr Source #

dataTypeOf :: XBindStmtTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data TransForm Source #

Constructors

ThenForm 
GroupForm 

Instances

Instances details
Data TransForm # 
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) -> TransForm -> c TransForm Source #

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

toConstr :: TransForm -> Constr Source #

dataTypeOf :: TransForm -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data ParStmtBlock idL idR Source #

Parenthesised Statement Block

Constructors

ParStmtBlock (XParStmtBlock idL idR) [ExprLStmt idL] [IdP idR] (SyntaxExpr idR) 
XParStmtBlock !(XXParStmtBlock idL idR) 

Instances

Instances details
Data (ParStmtBlock GhcTc GhcTc) # 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: ParStmtBlock GhcTc GhcTc -> Constr Source #

dataTypeOf :: ParStmtBlock GhcTc GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (ParStmtBlock GhcRn GhcRn) # 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: ParStmtBlock GhcRn GhcRn -> Constr Source #

dataTypeOf :: ParStmtBlock GhcRn GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (ParStmtBlock GhcPs GhcRn) # 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: ParStmtBlock GhcPs GhcRn -> Constr Source #

dataTypeOf :: ParStmtBlock GhcPs GhcRn -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> ParStmtBlock GhcPs GhcRn -> ParStmtBlock GhcPs GhcRn Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ParStmtBlock GhcPs GhcRn -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ParStmtBlock GhcPs GhcRn -> r Source #

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> ParStmtBlock GhcPs GhcRn -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ParStmtBlock GhcPs GhcRn -> m (ParStmtBlock GhcPs GhcRn) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ParStmtBlock GhcPs GhcRn -> m (ParStmtBlock GhcPs GhcRn) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ParStmtBlock GhcPs GhcRn -> m (ParStmtBlock GhcPs GhcRn) Source #

Data (ParStmtBlock GhcPs GhcPs) # 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: ParStmtBlock GhcPs GhcPs -> Constr Source #

dataTypeOf :: ParStmtBlock GhcPs GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

(Outputable (StmtLR idL idL (LHsExpr idL)), Outputable (XXParStmtBlock idL idR)) => Outputable (ParStmtBlock idL idR) # 
Instance details

Defined in GHC.Hs.Expr

Methods

ppr :: ParStmtBlock idL idR -> SDoc Source #

pprPrec :: Rational -> ParStmtBlock idL idR -> SDoc Source #

type FailOperator id = Maybe (SyntaxExpr id) Source #

The fail operator

This is used for `.. <-` "bind statments" in do notation, including non-monadic "binds" in applicative.

The fail operator is 'Just expr' if it potentially fail monadically. if the pattern match cannot fail, or shouldn't fail monadically (regular incomplete pattern exception), it is Nothing.

See Note [Monad fail : Rebindable syntax, overloaded strings] for the type of expression in the Just case, and why it is so.

See Note [Failing pattern matches in Stmts] for which contexts for '@BindStmt@'s should use the monadic fail and which shouldn't.

data ApplicativeArg idL Source #

Applicative Argument

Constructors

ApplicativeArgOne 

Fields

  • xarg_app_arg_one :: XApplicativeArgOne idL

    The fail operator, after renaming

    The fail operator is needed if this is a BindStmt where the pattern can fail. E.g.: (Just a) <- stmt The fail operator will be invoked if the pattern match fails. It is also used for guards in MonadComprehensions. The fail operator is Nothing if the pattern match can't fail

  • app_arg_pattern :: LPat idL
     
  • arg_expr :: LHsExpr idL
     
  • is_body_stmt :: Bool

    True = was a BodyStmt, False = was a BindStmt. See Note [Applicative BodyStmt]

ApplicativeArgMany 
XApplicativeArg !(XXApplicativeArg idL) 

Instances

Instances details
Data (ApplicativeArg GhcTc) # 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: ApplicativeArg GhcTc -> Constr Source #

dataTypeOf :: ApplicativeArg GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (ApplicativeArg GhcRn) # 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: ApplicativeArg GhcRn -> Constr Source #

dataTypeOf :: ApplicativeArg GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (ApplicativeArg GhcPs) # 
Instance details

Defined in GHC.Hs.Instances

Methods

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

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

toConstr :: ApplicativeArg GhcPs -> Constr Source #

dataTypeOf :: ApplicativeArg GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

OutputableBndrId idL => Outputable (ApplicativeArg (GhcPass idL)) # 
Instance details

Defined in GHC.Hs.Expr

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

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

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

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

pprDo :: (OutputableBndrId p, Outputable body) => HsStmtContext any -> [LStmt (GhcPass p) body] -> SDoc Source #

data HsSplice id Source #

Haskell Splice

Instances

Instances details
Data (HsSplice 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) -> HsSplice GhcTc -> c (HsSplice GhcTc) Source #

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

toConstr :: HsSplice GhcTc -> Constr Source #

dataTypeOf :: HsSplice GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsSplice 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) -> HsSplice GhcRn -> c (HsSplice GhcRn) Source #

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

toConstr :: HsSplice GhcRn -> Constr Source #

dataTypeOf :: HsSplice GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsSplice 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) -> HsSplice GhcPs -> c (HsSplice GhcPs) Source #

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

toConstr :: HsSplice GhcPs -> Constr Source #

dataTypeOf :: HsSplice GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

OutputableBndrId p => Outputable (HsSplice (GhcPass p)) # 
Instance details

Defined in GHC.Hs.Expr

newtype HsSplicedT Source #

Instances

Instances details
Data HsSplicedT # 
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) -> HsSplicedT -> c HsSplicedT Source #

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

toConstr :: HsSplicedT -> Constr Source #

dataTypeOf :: HsSplicedT -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data SpliceDecoration Source #

A splice can appear with various decorations wrapped around it. This data type captures explicitly how it was originally written, for use in the pretty printer.

Constructors

DollarSplice

$splice or $$splice

BareSplice

bare splice

Instances

Instances details
Eq SpliceDecoration # 
Instance details

Defined in GHC.Hs.Expr

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

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

toConstr :: SpliceDecoration -> Constr Source #

dataTypeOf :: SpliceDecoration -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Show SpliceDecoration # 
Instance details

Defined in GHC.Hs.Expr

Outputable SpliceDecoration # 
Instance details

Defined in GHC.Hs.Expr

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

Instances

Instances details
Data DelayedSplice # 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: DelayedSplice -> Constr Source #

dataTypeOf :: DelayedSplice -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data HsSplicedThing id Source #

Haskell Spliced Thing

Values that can result from running a splice.

Constructors

HsSplicedExpr (HsExpr id)

Haskell Spliced Expression

HsSplicedTy (HsType id)

Haskell Spliced Type

HsSplicedPat (Pat id)

Haskell Spliced Pattern

Instances

Instances details
Data (HsSplicedThing 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) -> HsSplicedThing GhcTc -> c (HsSplicedThing GhcTc) Source #

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

toConstr :: HsSplicedThing GhcTc -> Constr Source #

dataTypeOf :: HsSplicedThing GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsSplicedThing 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) -> HsSplicedThing GhcRn -> c (HsSplicedThing GhcRn) Source #

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

toConstr :: HsSplicedThing GhcRn -> Constr Source #

dataTypeOf :: HsSplicedThing GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsSplicedThing 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) -> HsSplicedThing GhcPs -> c (HsSplicedThing GhcPs) Source #

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

toConstr :: HsSplicedThing GhcPs -> Constr Source #

dataTypeOf :: HsSplicedThing GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

OutputableBndrId p => Outputable (HsSplicedThing (GhcPass p)) # 
Instance details

Defined in GHC.Hs.Expr

data PendingRnSplice Source #

Pending Renamer Splice

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

Defined in GHC.Hs.Expr

data UntypedSpliceFlavour Source #

Instances

Instances details
Data UntypedSpliceFlavour # 
Instance details

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: UntypedSpliceFlavour -> Constr Source #

dataTypeOf :: UntypedSpliceFlavour -> DataType Source #

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

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

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

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

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

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

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

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

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

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

data PendingTcSplice Source #

Pending Type-checker Splice

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

Defined in GHC.Hs.Expr

data HsBracket p Source #

Haskell Bracket

Constructors

ExpBr (XExpBr p) (LHsExpr p) 
PatBr (XPatBr p) (LPat p) 
DecBrL (XDecBrL p) [LHsDecl p] 
DecBrG (XDecBrG p) (HsGroup p) 
TypBr (XTypBr p) (LHsType p) 
VarBr (XVarBr p) Bool (IdP p) 
TExpBr (XTExpBr p) (LHsExpr p) 
XBracket !(XXBracket p) 

Instances

Instances details
Data (HsBracket 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) -> HsBracket GhcTc -> c (HsBracket GhcTc) Source #

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

toConstr :: HsBracket GhcTc -> Constr Source #

dataTypeOf :: HsBracket GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsBracket 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) -> HsBracket GhcRn -> c (HsBracket GhcRn) Source #

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

toConstr :: HsBracket GhcRn -> Constr Source #

dataTypeOf :: HsBracket GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsBracket 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) -> HsBracket GhcPs -> c (HsBracket GhcPs) Source #

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

toConstr :: HsBracket GhcPs -> Constr Source #

dataTypeOf :: HsBracket GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

OutputableBndrId p => Outputable (HsBracket (GhcPass p)) # 
Instance details

Defined in GHC.Hs.Expr

data ArithSeqInfo id Source #

Arithmetic Sequence Information

Constructors

From (LHsExpr id) 
FromThen (LHsExpr id) (LHsExpr id) 
FromTo (LHsExpr id) (LHsExpr id) 
FromThenTo (LHsExpr id) (LHsExpr id) (LHsExpr id) 

Instances

Instances details
Data (ArithSeqInfo 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) -> ArithSeqInfo GhcTc -> c (ArithSeqInfo GhcTc) Source #

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

toConstr :: ArithSeqInfo GhcTc -> Constr Source #

dataTypeOf :: ArithSeqInfo GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (ArithSeqInfo 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) -> ArithSeqInfo GhcRn -> c (ArithSeqInfo GhcRn) Source #

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

toConstr :: ArithSeqInfo GhcRn -> Constr Source #

dataTypeOf :: ArithSeqInfo GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (ArithSeqInfo 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) -> ArithSeqInfo GhcPs -> c (ArithSeqInfo GhcPs) Source #

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

toConstr :: ArithSeqInfo GhcPs -> Constr Source #

dataTypeOf :: ArithSeqInfo GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

OutputableBndrId p => Outputable (ArithSeqInfo (GhcPass p)) # 
Instance details

Defined in GHC.Hs.Expr

data HsMatchContext p Source #

Haskell Match Context

Context of a pattern match. This is more subtle than it would seem. See Note [Varieties of pattern matches].

Constructors

FunRhs 

Fields

LambdaExpr

Patterns of a lambda

CaseAlt

Patterns and guards on a case alternative

IfAlt

Guards of a multi-way if alternative

ProcExpr

Patterns of a proc

PatBindRhs

A pattern binding eg [y] <- e = e

PatBindGuards

Guards of pattern bindings, e.g., (Just b) | Just _ <- x = e | otherwise = e'

RecUpd

Record update [used only in GHC.HsToCore.Expr to tell matchWrapper what sort of runtime error message to generate]

StmtCtxt (HsStmtContext p)

Pattern of a do-stmt, list comprehension, pattern guard, etc

ThPatSplice

A Template Haskell pattern splice

ThPatQuote

A Template Haskell pattern quotation [p| (a,b) |]

PatSyn

A pattern synonym declaration

Instances

Instances details
Data (HsMatchContext 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) -> HsMatchContext GhcTc -> c (HsMatchContext GhcTc) Source #

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

toConstr :: HsMatchContext GhcTc -> Constr Source #

dataTypeOf :: HsMatchContext GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsMatchContext 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) -> HsMatchContext GhcRn -> c (HsMatchContext GhcRn) Source #

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

toConstr :: HsMatchContext GhcRn -> Constr Source #

dataTypeOf :: HsMatchContext GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsMatchContext 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) -> HsMatchContext GhcPs -> c (HsMatchContext GhcPs) Source #

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

toConstr :: HsMatchContext GhcPs -> Constr Source #

dataTypeOf :: HsMatchContext GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

OutputableBndrId p => Outputable (HsMatchContext (GhcPass p)) # 
Instance details

Defined in GHC.Hs.Expr

data HsStmtContext p Source #

Haskell Statement Context.

Constructors

ListComp 
MonadComp 
DoExpr (Maybe ModuleName)
ModuleName.
do { ... }
MDoExpr (Maybe ModuleName)
ModuleName.
mdo { ... } ie recursive do-expression
ArrowExpr

do-notation in an arrow-command context

GhciStmtCtxt

A command-line Stmt in GHCi pat <- rhs

PatGuard (HsMatchContext p)

Pattern guard for specified thing

ParStmtCtxt (HsStmtContext p)

A branch of a parallel stmt

TransStmtCtxt (HsStmtContext p)

A branch of a transform stmt

Instances

Instances details
Data (HsStmtContext 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) -> HsStmtContext GhcTc -> c (HsStmtContext GhcTc) Source #

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

toConstr :: HsStmtContext GhcTc -> Constr Source #

dataTypeOf :: HsStmtContext GhcTc -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsStmtContext 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) -> HsStmtContext GhcRn -> c (HsStmtContext GhcRn) Source #

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

toConstr :: HsStmtContext GhcRn -> Constr Source #

dataTypeOf :: HsStmtContext GhcRn -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data (HsStmtContext 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) -> HsStmtContext GhcPs -> c (HsStmtContext GhcPs) Source #

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

toConstr :: HsStmtContext GhcPs -> Constr Source #

dataTypeOf :: HsStmtContext GhcPs -> DataType Source #

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

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

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

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

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

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

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

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

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

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

OutputableBndrId p => Outputable (HsStmtContext (GhcPass p)) # 
Instance details

Defined in GHC.Hs.Expr

isMonadStmtContext :: HsStmtContext id -> Bool Source #

Is this a monadic context?