HsExpr

Abstract Haskell syntax for expressions.

Expressions proper

type LHsExpr p

Arguments

 = Located (HsExpr p)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Expression

type PostTcExpr = HsExpr GhcTc

Post-Type checking Expression

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

type PostTcTable = [(Name, PostTcExpr)]

Post-Type checking Table

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

noPostTcExpr :: PostTcExpr

noPostTcTable :: PostTcTable

data SyntaxExpr p

Syntax Expression

SyntaxExpr is like PostTcExpr, but it's filled in a little earlier, by the renamer. It's used for rebindable syntax.

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

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. This could be defined using PostRn and PostTc and such, but it's harder to get it all to work out that way. (noSyntaxExpr is hard to write, for example.)

Constructors

SyntaxExpr

Fields

• syn_expr :: HsExpr p
• syn_arg_wraps :: [HsWrapper]
• syn_res_wrap :: HsWrapper

Instances

DataId p => Data (SyntaxExpr p)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SyntaxExpr p -> c (SyntaxExpr p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SyntaxExpr p)

toConstr :: SyntaxExpr p -> Constr

dataTypeOf :: SyntaxExpr p -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SyntaxExpr p))

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

gmapT :: (forall b. Data b => b -> b) -> SyntaxExpr p -> SyntaxExpr p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SyntaxExpr p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SyntaxExpr p -> r

gmapQ :: (forall d. Data d => d -> u) -> SyntaxExpr p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SyntaxExpr p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SyntaxExpr p -> m (SyntaxExpr p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SyntaxExpr p -> m (SyntaxExpr p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SyntaxExpr p -> m (SyntaxExpr p)

(SourceTextX p, OutputableBndrId p) => Outputable (SyntaxExpr p)

Defined in HsExpr

Methods

ppr :: SyntaxExpr p -> SDoc

pprPrec :: Rational -> SyntaxExpr p -> SDoc

noExpr :: SourceTextX p => HsExpr p

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

noSyntaxExpr :: SourceTextX p => SyntaxExpr p

mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn

Make a 'SyntaxExpr Name' (the "rn" is because this is used in the renamer), missing its HsWrappers.

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

Command Syntax Table (for Arrow syntax)

data UnboundVar

An unbound variable; used for treating out-of-scope variables as expression holes

Constructors

OutOfScope OccName GlobalRdrEnv

An (unqualified) out-of-scope variable, together with the GlobalRdrEnv with respect to which it is unbound

TrueExprHole OccName

A "true" expression hole (_ or _x)

Instances

Data UnboundVar

Defined in HsExpr

Methods

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

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

toConstr :: UnboundVar -> Constr

dataTypeOf :: UnboundVar -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> UnboundVar -> UnboundVar

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

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

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

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

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

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

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

Outputable UnboundVar

Defined in HsExpr

Methods

ppr :: UnboundVar -> SDoc

pprPrec :: Rational -> UnboundVar -> SDoc

unboundVarOcc :: UnboundVar -> OccName

data HsExpr p

A Haskell expression.

Constructors

HsVar (Located (IdP p))

Variable

HsUnboundVar UnboundVar

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 ConLike

After typechecker only; must be different HsVar for pretty printing

HsRecFld (AmbiguousFieldOcc p)

Variable pointing to record selector Not in use after typechecking

HsOverLabel (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 HsIPName

Implicit parameter (not in use after typechecking)

HsOverLit (HsOverLit p)

Overloaded literals

HsLit (HsLit p)

Simple (non-overloaded) literals

HsLam (MatchGroup p (LHsExpr p))

Lambda abstraction. Currently always a single match

• AnnKeywordId : AnnLam, AnnRarrow,

HsLamCase (MatchGroup p (LHsExpr p))

Lambda-case

• AnnKeywordId : AnnLam, AnnCase,AnnOpen, AnnClose

HsApp (LHsExpr p) (LHsExpr p)

Application

HsAppType (LHsExpr p) (LHsWcType p)

Visible type application

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

• AnnKeywordId : AnnAt,

HsAppTypeOut (LHsExpr p) (LHsWcType GhcRn)

OpApp (LHsExpr p) (LHsExpr p) (PostRn p Fixity) (LHsExpr p)

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

NegApp (LHsExpr p) (SyntaxExpr p)

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

• AnnKeywordId : AnnMinus

HsPar (LHsExpr p)

Parenthesised expr; see Note [Parens in HsSyn]

SectionL (LHsExpr p) (LHsExpr p)

SectionR (LHsExpr p) (LHsExpr p)

ExplicitTuple [LHsTupArg p] Boxity

Used for explicit tuples and sections thereof

• AnnKeywordId : AnnOpen, AnnClose

ExplicitSum ConTag Arity (LHsExpr p) (PostTc p [Type])

Used for unboxed sum types

• AnnKeywordId : AnnOpen '(#', AnnVbar, AnnClose '#)',

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

HsCase (LHsExpr p) (MatchGroup p (LHsExpr p))

• AnnKeywordId : AnnCase, AnnOf,AnnOpen '{', AnnClose '}'

HsIf (Maybe (SyntaxExpr p)) (LHsExpr p) (LHsExpr p) (LHsExpr p)

• AnnKeywordId : AnnIf, AnnSemi, AnnThen,AnnSemi, AnnElse,

HsMultiIf (PostTc p Type) [LGRHS p (LHsExpr p)]

Multi-way if

• AnnKeywordId : AnnIf AnnOpen,AnnClose,

HsLet (LHsLocalBinds p) (LHsExpr p)

let(rec)

• AnnKeywordId : AnnLet, AnnOpen '{', AnnClose '}',AnnIn

HsDo (HsStmtContext Name) (Located [ExprLStmt p]) (PostTc p Type)

• AnnKeywordId : AnnDo, AnnOpen, AnnSemi, AnnVbar, AnnClose

ExplicitList (PostTc p Type) (Maybe (SyntaxExpr p)) [LHsExpr p]

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

• AnnKeywordId : AnnOpen '[', AnnClose ']'

ExplicitPArr (PostTc p Type) [LHsExpr p]

Syntactic parallel array: [:e1, ..., en:]

• AnnKeywordId : AnnOpen '[:', AnnDotdot,AnnComma, AnnVbar AnnClose ':]'

RecordCon

Record construction

• AnnKeywordId : AnnOpen '{', AnnDotdot,AnnClose '}'

Fields

• rcon_con_name :: Located (IdP p)
• rcon_con_like :: PostTc p ConLike
• rcon_con_expr :: PostTcExpr
• rcon_flds :: HsRecordBinds p

RecordUpd

Record update

• AnnKeywordId : AnnOpen '{', AnnDotdot,AnnClose '}'

Fields

• rupd_expr :: LHsExpr p
• rupd_flds :: [LHsRecUpdField p]
• rupd_cons :: PostTc p [ConLike]
• rupd_in_tys :: PostTc p [Type]
• rupd_out_tys :: PostTc p [Type]
• rupd_wrap :: PostTc p HsWrapper

ExprWithTySig (LHsExpr p) (LHsSigWcType p)

Expression with an explicit type signature. e :: type

• AnnKeywordId : AnnDcolon

ExprWithTySigOut (LHsExpr p) (LHsSigWcType GhcRn)

ArithSeq PostTcExpr (Maybe (SyntaxExpr p)) (ArithSeqInfo p)

Arithmetic sequence

• AnnKeywordId : AnnOpen '[', AnnComma,AnnDotdot, AnnClose ']'

PArrSeq PostTcExpr (ArithSeqInfo p)

Arithmetic sequence for parallel array

[:e1..e2:] or [:e1, e2..e3:]

• AnnKeywordId : AnnOpen '[:', AnnComma,AnnDotdot, AnnVbar, AnnClose ':]'

HsSCC SourceText StringLiteral (LHsExpr p)

• AnnKeywordId : AnnOpen '{-# SCC', AnnVal or AnnValStr, AnnClose '#-}'

HsCoreAnn SourceText StringLiteral (LHsExpr p)

• AnnKeywordId : AnnOpen '{-# CORE', AnnVal, AnnClose '#-}'

HsBracket (HsBracket p)

• AnnKeywordId : AnnOpen, AnnOpenE,AnnOpenEQ, AnnClose,AnnCloseQ

HsRnBracketOut (HsBracket GhcRn) [PendingRnSplice]

HsTcBracketOut (HsBracket GhcRn) [PendingTcSplice]

HsSpliceE (HsSplice p)

• AnnKeywordId : AnnOpen, AnnClose

HsProc (LPat p) (LHsCmdTop p)

proc notation for Arrows

• AnnKeywordId : AnnProc, AnnRarrow

HsStatic (PostRn p NameSet) (LHsExpr p)

• AnnKeywordId : AnnStatic,

HsArrApp (LHsExpr p) (LHsExpr p) (PostTc p Type) HsArrAppType Bool

• AnnKeywordId : Annlarrowtail, Annrarrowtail,AnnLarrowtail, AnnRarrowtail

HsArrForm (LHsExpr p) (Maybe Fixity) [LHsCmdTop p]

• AnnKeywordId : AnnOpenB '(|', AnnCloseB '|)'

HsTick (Tickish (IdP p)) (LHsExpr p)

HsBinTick Int Int (LHsExpr p)

HsTickPragma SourceText (StringLiteral, (Int, Int), (Int, Int)) ((SourceText, SourceText), (SourceText, SourceText)) (LHsExpr p)

• AnnKeywordId : AnnOpen, AnnOpen '{-# GENERATED', AnnVal,AnnVal, AnnColon,AnnVal, AnnMinus, AnnVal,AnnColon, AnnVal, AnnClose '#-}'

EWildPat

EAsPat (Located (IdP p)) (LHsExpr p)

• AnnKeywordId : AnnAt

EViewPat (LHsExpr p) (LHsExpr p)

• AnnKeywordId : AnnRarrow

ELazyPat (LHsExpr p)

• AnnKeywordId : AnnTilde

HsWrap HsWrapper (HsExpr p)

Instances

DataId p => Data (HsExpr p)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsExpr p -> c (HsExpr p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsExpr p)

toConstr :: HsExpr p -> Constr

dataTypeOf :: HsExpr p -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> HsExpr p -> HsExpr p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsExpr p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsExpr p -> r

gmapQ :: (forall d. Data d => d -> u) -> HsExpr p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsExpr p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsExpr p -> m (HsExpr p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsExpr p -> m (HsExpr p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsExpr p -> m (HsExpr p)

(SourceTextX p, OutputableBndrId p) => Outputable (HsExpr p)

Defined in HsExpr

Methods

ppr :: HsExpr p -> SDoc

pprPrec :: Rational -> HsExpr p -> SDoc

type LHsTupArg id = Located (HsTupArg id)

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

• AnnKeywordId : AnnComma

Haskell Tuple Argument

Constructors

Present (LHsExpr id)

The argument

Missing (PostTc id Type)

The argument is missing, but this is its type

Instances

DataId id => Data (HsTupArg id)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTupArg id -> c (HsTupArg id)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsTupArg id)

toConstr :: HsTupArg id -> Constr

dataTypeOf :: HsTupArg id -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> HsTupArg id -> HsTupArg id

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTupArg id -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTupArg id -> r

gmapQ :: (forall d. Data d => d -> u) -> HsTupArg id -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTupArg id -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTupArg id -> m (HsTupArg id)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTupArg id -> m (HsTupArg id)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTupArg id -> m (HsTupArg id)

tupArgPresent :: LHsTupArg id -> Bool

pprLExpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc

pprExpr :: (SourceTextX p, OutputableBndrId p) => HsExpr p -> SDoc

isQuietHsExpr :: HsExpr id -> Bool

pprBinds :: (SourceTextX idL, SourceTextX idR, OutputableBndrId idL, OutputableBndrId idR) => HsLocalBindsLR idL idR -> SDoc

ppr_lexpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc

ppr_expr :: forall p. (SourceTextX p, OutputableBndrId p) => HsExpr p -> SDoc

data LHsWcTypeX

Located Haskell Wildcard Type Expression

Constructors

(SourceTextX p, OutputableBndrId p) => LHsWcTypeX (LHsWcType p)

ppr_apps :: (SourceTextX p, OutputableBndrId p) => HsExpr p -> [Either (LHsExpr p) LHsWcTypeX] -> SDoc

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

pprDebugParendExpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc

pprParendLExpr :: (SourceTextX p, OutputableBndrId p) => LHsExpr p -> SDoc

pprParendExpr :: (SourceTextX p, OutputableBndrId p) => HsExpr p -> SDoc

hsExprNeedsParens :: HsExpr id -> Bool

isAtomicHsExpr :: HsExpr id -> Bool

type LHsCmd id = Located (HsCmd id)

Located Haskell Command (for arrow syntax)

data HsCmd id

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

Constructors

HsCmdArrApp (LHsExpr id) (LHsExpr id) (PostTc id Type) HsArrAppType Bool

• AnnKeywordId : Annlarrowtail, Annrarrowtail,AnnLarrowtail, AnnRarrowtail

HsCmdArrForm (LHsExpr id) LexicalFixity (Maybe Fixity) [LHsCmdTop id]

• AnnKeywordId : AnnOpenB '(|', AnnCloseB '|)'

HsCmdApp (LHsCmd id) (LHsExpr id)

HsCmdLam (MatchGroup id (LHsCmd id))

• AnnKeywordId : AnnLam, AnnRarrow,

HsCmdPar (LHsCmd id)

• AnnKeywordId : AnnOpen '(', AnnClose ')'

HsCmdCase (LHsExpr id) (MatchGroup id (LHsCmd id))

• AnnKeywordId : AnnCase, AnnOf,AnnOpen '{', AnnClose '}'

HsCmdIf (Maybe (SyntaxExpr id)) (LHsExpr id) (LHsCmd id) (LHsCmd id)

• AnnKeywordId : AnnIf, AnnSemi, AnnThen,AnnSemi, AnnElse,

HsCmdLet (LHsLocalBinds id) (LHsCmd id)

• AnnKeywordId : AnnLet, AnnOpen '{', AnnClose '}',AnnIn

HsCmdDo (Located [CmdLStmt id]) (PostTc id Type)

• AnnKeywordId : AnnDo, AnnOpen, AnnSemi, AnnVbar, AnnClose

HsCmdWrap HsWrapper (HsCmd id)

Instances

DataId id => Data (HsCmd id)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsCmd id -> c (HsCmd id)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsCmd id)

toConstr :: HsCmd id -> Constr

dataTypeOf :: HsCmd id -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> HsCmd id -> HsCmd id

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsCmd id -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsCmd id -> r

gmapQ :: (forall d. Data d => d -> u) -> HsCmd id -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsCmd id -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsCmd id -> m (HsCmd id)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsCmd id -> m (HsCmd id)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsCmd id -> m (HsCmd id)

(SourceTextX p, OutputableBndrId p) => Outputable (HsCmd p)

Defined in HsExpr

Methods

ppr :: HsCmd p -> SDoc

pprPrec :: Rational -> HsCmd p -> SDoc

data HsArrAppType

Haskell Array Application Type

Constructors

HsHigherOrderApp

HsFirstOrderApp

Instances

Data HsArrAppType

Defined in HsExpr

Methods

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

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

toConstr :: HsArrAppType -> Constr

dataTypeOf :: HsArrAppType -> DataType

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

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

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

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

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

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

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

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

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

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

type LHsCmdTop p = Located (HsCmdTop p)

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

Haskell Top-level Command

Constructors

HsCmdTop (LHsCmd p) (PostTc p Type) (PostTc p Type) (CmdSyntaxTable p)

Instances

DataId p => Data (HsCmdTop p)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsCmdTop p -> c (HsCmdTop p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsCmdTop p)

toConstr :: HsCmdTop p -> Constr

dataTypeOf :: HsCmdTop p -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> HsCmdTop p -> HsCmdTop p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsCmdTop p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsCmdTop p -> r

gmapQ :: (forall d. Data d => d -> u) -> HsCmdTop p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsCmdTop p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsCmdTop p -> m (HsCmdTop p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsCmdTop p -> m (HsCmdTop p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsCmdTop p -> m (HsCmdTop p)

(SourceTextX p, OutputableBndrId p) => Outputable (HsCmdTop p)

Defined in HsExpr

Methods

ppr :: HsCmdTop p -> SDoc

pprPrec :: Rational -> HsCmdTop p -> SDoc

pprLCmd :: (SourceTextX p, OutputableBndrId p) => LHsCmd p -> SDoc

pprCmd :: (SourceTextX p, OutputableBndrId p) => HsCmd p -> SDoc

isQuietHsCmd :: HsCmd id -> Bool

ppr_lcmd :: (SourceTextX p, OutputableBndrId p) => LHsCmd p -> SDoc

ppr_cmd :: forall p. (SourceTextX p, OutputableBndrId p) => HsCmd p -> SDoc

pprCmdArg :: (SourceTextX p, OutputableBndrId p) => HsCmdTop p -> SDoc

type HsRecordBinds p = HsRecFields p (LHsExpr p)

Haskell Record Bindings

data MatchGroup p body

Constructors

MG

Fields

• mg_alts :: Located [LMatch p body]
• mg_arg_tys :: [PostTc p Type]
• mg_res_ty :: PostTc p Type
• mg_origin :: Origin

Instances

(Data body, DataId p) => Data (MatchGroup p body)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MatchGroup p body -> c (MatchGroup p body)

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

toConstr :: MatchGroup p body -> Constr

dataTypeOf :: MatchGroup p body -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> MatchGroup p body -> MatchGroup p body

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup p body -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroup p body -> r

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroup p body -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MatchGroup p body -> m (MatchGroup p body)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup p body -> m (MatchGroup p body)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroup p body -> m (MatchGroup p body)

type LMatch id body = Located (Match id body)

Located Match

May have AnnKeywordId : AnnSemi when in a list

data Match p body

Constructors

Match

Fields

• m_ctxt :: HsMatchContext (NameOrRdrName (IdP p))
• m_pats :: [LPat p]
• m_grhss :: GRHSs p body

Instances

(Data body, DataId p) => Data (Match p body)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match p body -> c (Match p body)

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

toConstr :: Match p body -> Constr

dataTypeOf :: Match p body -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> Match p body -> Match p body

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match p body -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match p body -> r

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match p body -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match p body -> m (Match p body)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match p body -> m (Match p body)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match p body -> m (Match p body)

(SourceTextX idR, OutputableBndrId idR, Outputable body) => Outputable (Match idR body)

Defined in HsExpr

Methods

ppr :: Match idR body -> SDoc

pprPrec :: Rational -> Match idR body -> SDoc

isInfixMatch :: Match id body -> Bool

isEmptyMatchGroup :: MatchGroup id body -> Bool

isSingletonMatchGroup :: [LMatch id body] -> Bool

Is there only one RHS in this list of matches?

matchGroupArity :: MatchGroup id body -> Arity

hsLMatchPats :: LMatch id body -> [LPat id]

data GRHSs p body

Guarded Right-Hand Sides

GRHSs are used both for pattern bindings and for Matches

• AnnKeywordId : AnnVbar, AnnEqual,AnnWhere, AnnOpen,AnnClose AnnRarrow,AnnSemi

Constructors

GRHSs

Fields

• grhssGRHSs :: [LGRHS p body]

  Guarded RHSs

• grhssLocalBinds :: LHsLocalBinds p

  The where clause

Instances

(Data body, DataId p) => Data (GRHSs p body)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHSs p body -> c (GRHSs p body)

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

toConstr :: GRHSs p body -> Constr

dataTypeOf :: GRHSs p body -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> GRHSs p body -> GRHSs p body

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs p body -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHSs p body -> r

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHSs p body -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHSs p body -> m (GRHSs p body)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs p body -> m (GRHSs p body)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHSs p body -> m (GRHSs p body)

type LGRHS id body = Located (GRHS id body)

Located Guarded Right-Hand Side

data GRHS id body

Guarded Right Hand Side.

Constructors

GRHS [GuardLStmt id] body

Instances

(Data body, DataId id) => Data (GRHS id body)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GRHS id body -> c (GRHS id body)

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

toConstr :: GRHS id body -> Constr

dataTypeOf :: GRHS id body -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> GRHS id body -> GRHS id body

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GRHS id body -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GRHS id body -> r

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

gmapQi :: Int -> (forall d. Data d => d -> u) -> GRHS id body -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GRHS id body -> m (GRHS id body)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS id body -> m (GRHS id body)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GRHS id body -> m (GRHS id body)

pprMatches :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => MatchGroup idR body -> SDoc

pprFunBind :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => MatchGroup idR body -> SDoc

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

pprMatch :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => Match idR body -> SDoc

pprGRHSs :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHSs idR body -> SDoc

pprGRHS :: (SourceTextX idR, OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHS idR body -> SDoc

pp_rhs :: Outputable body => HsMatchContext idL -> body -> SDoc

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

Located do block Statement

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

Located Statement with separate Left and Right id's

type Stmt id body = StmtLR id id body

do block Statement

type CmdLStmt id = LStmt id (LHsCmd id)

Command Located Statement

type CmdStmt id = Stmt id (LHsCmd id)

Command Statement

type ExprLStmt id = LStmt id (LHsExpr id)

Expression Located Statement

type ExprStmt id = Stmt id (LHsExpr id)

Expression Statement

type GuardLStmt id = LStmt id (LHsExpr id)

Guard Located Statement

type GuardStmt id = Stmt id (LHsExpr id)

Guard Statement

type GhciLStmt id = LStmt id (LHsExpr id)

Ghci Located Statement

type GhciStmt id = Stmt id (LHsExpr id)

Ghci Statement

data StmtLR idL idR body

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

Constructors

LastStmt body Bool (SyntaxExpr idR)

BindStmt (LPat idL) body (SyntaxExpr idR) (SyntaxExpr idR) (PostTc idR Type)

ApplicativeStmt [(SyntaxExpr idR, ApplicativeArg idL idR)] (Maybe (SyntaxExpr idR)) (PostTc idR Type)

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 RnExpr

BodyStmt body (SyntaxExpr idR) (SyntaxExpr idR) (PostTc idR Type)

LetStmt (LHsLocalBindsLR idL idR)

• AnnKeywordId : AnnLet AnnOpen '{',AnnClose '}',

ParStmt [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR) (PostTc idR Type)

TransStmt

Fields

• trS_form :: TransForm
• trS_stmts :: [ExprLStmt idL]
• trS_bndrs :: [(IdP idR, IdP idR)]
• trS_using :: LHsExpr idR
• trS_by :: Maybe (LHsExpr idR)
• trS_ret :: SyntaxExpr idR
• trS_bind :: SyntaxExpr idR
• trS_bind_arg_ty :: PostTc idR Type
• trS_fmap :: HsExpr idR

RecStmt

• AnnKeywordId : AnnRec

Fields

• recS_stmts :: [LStmtLR idL idR body]
• recS_later_ids :: [IdP idR]
• recS_rec_ids :: [IdP idR]
• recS_bind_fn :: SyntaxExpr idR
• recS_ret_fn :: SyntaxExpr idR
• recS_mfix_fn :: SyntaxExpr idR
• recS_bind_ty :: PostTc idR Type
• recS_later_rets :: [PostTcExpr]
• recS_rec_rets :: [PostTcExpr]
• recS_ret_ty :: PostTc idR Type

Instances

(Data body, DataId idL, DataId idR) => Data (StmtLR idL idR body)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> StmtLR idL idR body -> c (StmtLR idL idR body)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (StmtLR idL idR body)

toConstr :: StmtLR idL idR body -> Constr

dataTypeOf :: StmtLR idL idR body -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (StmtLR idL idR body))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (StmtLR idL idR body))

gmapT :: (forall b. Data b => b -> b) -> StmtLR idL idR body -> StmtLR idL idR body

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR idL idR body -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> StmtLR idL idR body -> r

gmapQ :: (forall d. Data d => d -> u) -> StmtLR idL idR body -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> StmtLR idL idR body -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> StmtLR idL idR body -> m (StmtLR idL idR body)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR idL idR body -> m (StmtLR idL idR body)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> StmtLR idL idR body -> m (StmtLR idL idR body)

(SourceTextX idL, SourceTextX idR, OutputableBndrId idL, OutputableBndrId idR, Outputable body) => Outputable (StmtLR idL idR body)

Defined in HsExpr

Methods

ppr :: StmtLR idL idR body -> SDoc

pprPrec :: Rational -> StmtLR idL idR body -> SDoc

data TransForm

Constructors

ThenForm

GroupForm

Instances

Data TransForm

Defined in HsExpr

Methods

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

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

toConstr :: TransForm -> Constr

dataTypeOf :: TransForm -> DataType

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

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

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

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

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

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

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

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

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

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

data ParStmtBlock idL idR

Parenthesised Statement Block

Constructors

ParStmtBlock [ExprLStmt idL] [IdP idR] (SyntaxExpr idR)

Instances

(DataId idL, DataId idR) => Data (ParStmtBlock idL idR)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ParStmtBlock idL idR -> c (ParStmtBlock idL idR)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ParStmtBlock idL idR)

toConstr :: ParStmtBlock idL idR -> Constr

dataTypeOf :: ParStmtBlock idL idR -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ParStmtBlock idL idR))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ParStmtBlock idL idR))

gmapT :: (forall b. Data b => b -> b) -> ParStmtBlock idL idR -> ParStmtBlock idL idR

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ParStmtBlock idL idR -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ParStmtBlock idL idR -> r

gmapQ :: (forall d. Data d => d -> u) -> ParStmtBlock idL idR -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ParStmtBlock idL idR -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ParStmtBlock idL idR -> m (ParStmtBlock idL idR)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ParStmtBlock idL idR -> m (ParStmtBlock idL idR)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ParStmtBlock idL idR -> m (ParStmtBlock idL idR)

(SourceTextX idL, OutputableBndrId idL) => Outputable (ParStmtBlock idL idR)

Defined in HsExpr

Methods

ppr :: ParStmtBlock idL idR -> SDoc

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

data ApplicativeArg idL idR

Applicative Argument

Constructors

ApplicativeArgOne (LPat idL) (LHsExpr idL) Bool

ApplicativeArgMany [ExprLStmt idL] (HsExpr idL) (LPat idL)

Instances

(DataId idL, DataId idR) => Data (ApplicativeArg idL idR)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ApplicativeArg idL idR -> c (ApplicativeArg idL idR)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ApplicativeArg idL idR)

toConstr :: ApplicativeArg idL idR -> Constr

dataTypeOf :: ApplicativeArg idL idR -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ApplicativeArg idL idR))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ApplicativeArg idL idR))

gmapT :: (forall b. Data b => b -> b) -> ApplicativeArg idL idR -> ApplicativeArg idL idR

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ApplicativeArg idL idR -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ApplicativeArg idL idR -> r

gmapQ :: (forall d. Data d => d -> u) -> ApplicativeArg idL idR -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ApplicativeArg idL idR -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ApplicativeArg idL idR -> m (ApplicativeArg idL idR)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ApplicativeArg idL idR -> m (ApplicativeArg idL idR)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ApplicativeArg idL idR -> m (ApplicativeArg idL idR)

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

pprTransformStmt :: (SourceTextX p, OutputableBndrId p) => [IdP p] -> LHsExpr p -> Maybe (LHsExpr p) -> SDoc

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

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

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

ppr_do_stmts :: (SourceTextX idL, SourceTextX idR, OutputableBndrId idL, OutputableBndrId idR, Outputable body) => [LStmtLR idL idR body] -> SDoc

pprComp :: (SourceTextX p, OutputableBndrId p, Outputable body) => [LStmt p body] -> SDoc

pprQuals :: (SourceTextX p, OutputableBndrId p, Outputable body) => [LStmt p body] -> SDoc

data HsSplice id

Haskell Splice

Constructors

HsTypedSplice SpliceDecoration (IdP id) (LHsExpr id)

HsUntypedSplice SpliceDecoration (IdP id) (LHsExpr id)

HsQuasiQuote (IdP id) (IdP id) SrcSpan FastString

HsSpliced ThModFinalizers (HsSplicedThing id)

Instances

DataId id => Data (HsSplice id)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSplice id -> c (HsSplice id)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsSplice id)

toConstr :: HsSplice id -> Constr

dataTypeOf :: HsSplice id -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> HsSplice id -> HsSplice id

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSplice id -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSplice id -> r

gmapQ :: (forall d. Data d => d -> u) -> HsSplice id -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSplice id -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSplice id -> m (HsSplice id)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSplice id -> m (HsSplice id)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSplice id -> m (HsSplice id)

(SourceTextX p, OutputableBndrId p) => Outputable (HsSplice p)

Defined in HsExpr

Methods

ppr :: HsSplice p -> SDoc

pprPrec :: Rational -> HsSplice p -> SDoc

data SpliceDecoration

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

HasParens

$( splice ) or $$( splice )

HasDollar

$splice or $$splice

NoParens

bare splice

Instances

Eq SpliceDecoration

Defined in HsExpr

Methods

(==) :: SpliceDecoration -> SpliceDecoration -> Bool

(/=) :: SpliceDecoration -> SpliceDecoration -> Bool

Data SpliceDecoration

Defined in HsExpr

Methods

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

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

toConstr :: SpliceDecoration -> Constr

dataTypeOf :: SpliceDecoration -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> SpliceDecoration -> SpliceDecoration

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

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

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

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

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

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

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

Show SpliceDecoration

Defined in HsExpr

Methods

showsPrec :: Int -> SpliceDecoration -> ShowS

show :: SpliceDecoration -> String

showList :: [SpliceDecoration] -> ShowS

Outputable SpliceDecoration

Defined in HsExpr

Methods

ppr :: SpliceDecoration -> SDoc

pprPrec :: Rational -> SpliceDecoration -> SDoc

isTypedSplice :: HsSplice id -> Bool

newtype ThModFinalizers

Finalizers produced by a splice with addModFinalizer

See Note [Delaying modFinalizers in untyped splices] in RnSplice. For how this is used.

Constructors

ThModFinalizers [ForeignRef (Q ())]

Instances

Data ThModFinalizers

Defined in HsExpr

Methods

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

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

toConstr :: ThModFinalizers -> Constr

dataTypeOf :: ThModFinalizers -> DataType

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

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

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

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

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

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

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

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

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

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

data HsSplicedThing id

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

DataId id => Data (HsSplicedThing id)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSplicedThing id -> c (HsSplicedThing id)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsSplicedThing id)

toConstr :: HsSplicedThing id -> Constr

dataTypeOf :: HsSplicedThing id -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsSplicedThing id))

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

gmapT :: (forall b. Data b => b -> b) -> HsSplicedThing id -> HsSplicedThing id

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSplicedThing id -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSplicedThing id -> r

gmapQ :: (forall d. Data d => d -> u) -> HsSplicedThing id -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSplicedThing id -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSplicedThing id -> m (HsSplicedThing id)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSplicedThing id -> m (HsSplicedThing id)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSplicedThing id -> m (HsSplicedThing id)

(SourceTextX p, OutputableBndrId p) => Outputable (HsSplicedThing p)

Defined in HsExpr

Methods

ppr :: HsSplicedThing p -> SDoc

pprPrec :: Rational -> HsSplicedThing p -> SDoc

type SplicePointName = Name

data PendingRnSplice

Pending Renamer Splice

Constructors

PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)

Instances

Data PendingRnSplice

Defined in HsExpr

Methods

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

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

toConstr :: PendingRnSplice -> Constr

dataTypeOf :: PendingRnSplice -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> PendingRnSplice -> PendingRnSplice

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

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

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

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

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

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

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

Outputable PendingRnSplice

Defined in HsExpr

Methods

ppr :: PendingRnSplice -> SDoc

pprPrec :: Rational -> PendingRnSplice -> SDoc

data UntypedSpliceFlavour

Constructors

UntypedExpSplice

UntypedPatSplice

UntypedTypeSplice

UntypedDeclSplice

Instances

Data UntypedSpliceFlavour

Defined in HsExpr

Methods

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

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

toConstr :: UntypedSpliceFlavour -> Constr

dataTypeOf :: UntypedSpliceFlavour -> DataType

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

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

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

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

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

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

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

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

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

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

data PendingTcSplice

Pending Type-checker Splice

Constructors

PendingTcSplice SplicePointName (LHsExpr GhcTc)

Instances

Data PendingTcSplice

Defined in HsExpr

Methods

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

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

toConstr :: PendingTcSplice -> Constr

dataTypeOf :: PendingTcSplice -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> PendingTcSplice -> PendingTcSplice

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

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

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

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

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

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

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

Outputable PendingTcSplice

Defined in HsExpr

Methods

ppr :: PendingTcSplice -> SDoc

pprPrec :: Rational -> PendingTcSplice -> SDoc

pprPendingSplice :: (SourceTextX p, OutputableBndrId p) => SplicePointName -> LHsExpr p -> SDoc

pprSpliceDecl :: (SourceTextX p, OutputableBndrId p) => HsSplice p -> SpliceExplicitFlag -> SDoc

ppr_splice_decl :: (SourceTextX p, OutputableBndrId p) => HsSplice p -> SDoc

pprSplice :: (SourceTextX p, OutputableBndrId p) => HsSplice p -> SDoc

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

ppr_splice :: (SourceTextX p, OutputableBndrId p) => SDoc -> IdP p -> LHsExpr p -> SDoc -> SDoc

data HsBracket p

Haskell Bracket

Constructors

ExpBr (LHsExpr p)

PatBr (LPat p)

DecBrL [LHsDecl p]

DecBrG (HsGroup p)

TypBr (LHsType p)

VarBr Bool (IdP p)

TExpBr (LHsExpr p)

Instances

DataId p => Data (HsBracket p)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsBracket p -> c (HsBracket p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsBracket p)

toConstr :: HsBracket p -> Constr

dataTypeOf :: HsBracket p -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsBracket p))

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

gmapT :: (forall b. Data b => b -> b) -> HsBracket p -> HsBracket p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsBracket p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsBracket p -> r

gmapQ :: (forall d. Data d => d -> u) -> HsBracket p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsBracket p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsBracket p -> m (HsBracket p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBracket p -> m (HsBracket p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsBracket p -> m (HsBracket p)

(SourceTextX p, OutputableBndrId p) => Outputable (HsBracket p)

Defined in HsExpr

Methods

ppr :: HsBracket p -> SDoc

pprPrec :: Rational -> HsBracket p -> SDoc

isTypedBracket :: HsBracket id -> Bool

pprHsBracket :: (SourceTextX p, OutputableBndrId p) => HsBracket p -> SDoc

thBrackets :: SDoc -> SDoc -> SDoc

thTyBrackets :: SDoc -> SDoc

data ArithSeqInfo id

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

DataId id => Data (ArithSeqInfo id)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ArithSeqInfo id -> c (ArithSeqInfo id)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ArithSeqInfo id)

toConstr :: ArithSeqInfo id -> Constr

dataTypeOf :: ArithSeqInfo id -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ArithSeqInfo id))

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

gmapT :: (forall b. Data b => b -> b) -> ArithSeqInfo id -> ArithSeqInfo id

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArithSeqInfo id -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArithSeqInfo id -> r

gmapQ :: (forall d. Data d => d -> u) -> ArithSeqInfo id -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ArithSeqInfo id -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArithSeqInfo id -> m (ArithSeqInfo id)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArithSeqInfo id -> m (ArithSeqInfo id)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArithSeqInfo id -> m (ArithSeqInfo id)

(SourceTextX p, OutputableBndrId p) => Outputable (ArithSeqInfo p)

Defined in HsExpr

Methods

ppr :: ArithSeqInfo p -> SDoc

pprPrec :: Rational -> ArithSeqInfo p -> SDoc

pp_dotdot :: SDoc

data HsMatchContext id

Haskell Match Context

Context of a pattern match. This is more subtle than it would seem. See Note [Varieties of pattern matches].

Constructors

FunRhs

A pattern matching on an argument of a function binding

Fields

• mc_fun :: Located id

  function binder of f

• mc_fixity :: LexicalFixity

  fixing of f

• mc_strictness :: SrcStrictness

  was f banged? See Note [FunBind vs PatBind]

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

RecUpd

Record update [used only in DsExpr to tell matchWrapper what sort of runtime error message to generate]

StmtCtxt (HsStmtContext id)

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

Functor HsMatchContext

Defined in HsExpr

Methods

fmap :: (a -> b) -> HsMatchContext a -> HsMatchContext b

(<$) :: a -> HsMatchContext b -> HsMatchContext a

Data id => Data (HsMatchContext id)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMatchContext id -> c (HsMatchContext id)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMatchContext id)

toConstr :: HsMatchContext id -> Constr

dataTypeOf :: HsMatchContext id -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMatchContext id))

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

gmapT :: (forall b. Data b => b -> b) -> HsMatchContext id -> HsMatchContext id

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMatchContext id -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMatchContext id -> r

gmapQ :: (forall d. Data d => d -> u) -> HsMatchContext id -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMatchContext id -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id)

OutputableBndr id => Outputable (HsMatchContext id)

Defined in HsExpr

Methods

ppr :: HsMatchContext id -> SDoc

pprPrec :: Rational -> HsMatchContext id -> SDoc

isPatSynCtxt :: HsMatchContext id -> Bool

data HsStmtContext id

Haskell Statement Context. It expects to be parameterised with one of RdrName, Name or Id

Constructors

ListComp

MonadComp

PArrComp

Parallel array comprehension

DoExpr

do { ... }

MDoExpr

mdo { ... } ie recursive do-expression

ArrowExpr

do-notation in an arrow-command context

GhciStmtCtxt

A command-line Stmt in GHCi pat <- rhs

PatGuard (HsMatchContext id)

Pattern guard for specified thing

ParStmtCtxt (HsStmtContext id)

A branch of a parallel stmt

TransStmtCtxt (HsStmtContext id)

A branch of a transform stmt

Instances

Functor HsStmtContext

Defined in HsExpr

Methods

fmap :: (a -> b) -> HsStmtContext a -> HsStmtContext b

(<$) :: a -> HsStmtContext b -> HsStmtContext a

Data id => Data (HsStmtContext id)

Defined in HsExpr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsStmtContext id -> c (HsStmtContext id)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsStmtContext id)

toConstr :: HsStmtContext id -> Constr

dataTypeOf :: HsStmtContext id -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsStmtContext id))

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

gmapT :: (forall b. Data b => b -> b) -> HsStmtContext id -> HsStmtContext id

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsStmtContext id -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsStmtContext id -> r

gmapQ :: (forall d. Data d => d -> u) -> HsStmtContext id -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsStmtContext id -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id)

(Outputable p, Outputable (NameOrRdrName p)) => Outputable (HsStmtContext p)

Defined in HsExpr

Methods

ppr :: HsStmtContext p -> SDoc

pprPrec :: Rational -> HsStmtContext p -> SDoc

isListCompExpr :: HsStmtContext id -> Bool

isMonadCompExpr :: HsStmtContext id -> Bool

isMonadFailStmtContext :: HsStmtContext id -> Bool

Should pattern match failure in a HsStmtContext be desugared using MonadFail?

matchSeparator :: HsMatchContext id -> SDoc

pprMatchContext :: (Outputable (NameOrRdrName id), Outputable id) => HsMatchContext id -> SDoc

pprMatchContextNoun :: (Outputable (NameOrRdrName id), Outputable id) => HsMatchContext id -> SDoc

pprAStmtContext :: (Outputable id, Outputable (NameOrRdrName id)) => HsStmtContext id -> SDoc

pprStmtContext :: (Outputable id, Outputable (NameOrRdrName id)) => HsStmtContext id -> SDoc

matchContextErrString :: Outputable id => HsMatchContext id -> SDoc

pprMatchInCtxt :: (SourceTextX idR, OutputableBndrId idR, Outputable (NameOrRdrName (NameOrRdrName (IdP idR))), Outputable body) => Match idR body -> SDoc

pprStmtInCtxt :: (SourceTextX idL, SourceTextX idR, OutputableBndrId idL, OutputableBndrId idR, Outputable body) => HsStmtContext (IdP idL) -> StmtLR idL idR body -> SDoc