ghc-7.10.2: The GHC API

Safe HaskellNone




Abstract Haskell syntax for expressions.


Expressions proper

type LHsExpr id Source


 = Located (HsExpr id)

May have AnnKeywordId : AnnComma when in a list

type PostTcExpr = HsExpr Id Source

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

type PostTcTable = [(Name, PostTcExpr)] Source

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

type SyntaxExpr id = HsExpr id Source

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

data HsExpr id Source

A Haskell expression.


HsVar id


HsIPVar HsIPName

Implicit parameter

HsOverLit (HsOverLit id)

Overloaded literals

HsLit HsLit

Simple (non-overloaded) literals

HsLam (MatchGroup id (LHsExpr id))

Lambda abstraction. Currently always a single match

HsLamCase (PostTc id Type) (MatchGroup id (LHsExpr id))


HsApp (LHsExpr id) (LHsExpr id)


OpApp (LHsExpr id) (LHsExpr id) (PostRn id Fixity) (LHsExpr id)

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

NegApp (LHsExpr id) (SyntaxExpr id)

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

HsPar (LHsExpr id)

Parenthesised expr; see Note [Parens in HsSyn]

SectionL (LHsExpr id) (LHsExpr id) 
SectionR (LHsExpr id) (LHsExpr id) 
ExplicitTuple [LHsTupArg id] Boxity

Used for explicit tuples and sections thereof

HsCase (LHsExpr id) (MatchGroup id (LHsExpr id))
HsIf (Maybe (SyntaxExpr id)) (LHsExpr id) (LHsExpr id) (LHsExpr id)
HsMultiIf (PostTc id Type) [LGRHS id (LHsExpr id)]

Multi-way if

HsLet (HsLocalBinds id) (LHsExpr id)


HsDo (HsStmtContext Name) [ExprLStmt id] (PostTc id Type)
ExplicitList (PostTc id Type) (Maybe (SyntaxExpr id)) [LHsExpr id]

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

ExplicitPArr (PostTc id Type) [LHsExpr id]

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

RecordCon (Located id) PostTcExpr (HsRecordBinds id)

Record construction

RecordUpd (LHsExpr id) (HsRecordBinds id) [DataCon] [PostTc id Type] [PostTc id Type]

Record update

ExprWithTySig (LHsExpr id) (LHsType id) (PostRn id [Name])

Expression with an explicit type signature. e :: type

ExprWithTySigOut (LHsExpr id) (LHsType Name) 
ArithSeq PostTcExpr (Maybe (SyntaxExpr id)) (ArithSeqInfo id)

Arithmetic sequence

PArrSeq PostTcExpr (ArithSeqInfo id)

Arithmetic sequence for parallel array

[:e1..e2:] or [:e1, e2..e3:]
HsSCC SourceText FastString (LHsExpr id)
HsCoreAnn SourceText FastString (LHsExpr id)
HsBracket (HsBracket id)
HsRnBracketOut (HsBracket Name) [PendingRnSplice] 
HsTcBracketOut (HsBracket Name) [PendingTcSplice] 
HsSpliceE Bool (HsSplice id)
HsQuasiQuoteE (HsQuasiQuote id) 
HsProc (LPat id) (LHsCmdTop id)

proc notation for Arrows

HsStatic (LHsExpr id)
HsArrApp (LHsExpr id) (LHsExpr id) (PostTc id Type) HsArrAppType Bool
HsArrForm (LHsExpr id) (Maybe Fixity) [LHsCmdTop id]
HsTick (Tickish id) (LHsExpr id) 
HsBinTick Int Int (LHsExpr id) 
HsTickPragma SourceText (FastString, (Int, Int), (Int, Int)) (LHsExpr id)
EAsPat (Located id) (LHsExpr id)
EViewPat (LHsExpr id) (LHsExpr id)
ELazyPat (LHsExpr id)
HsType (LHsType id) 
HsWrap HsWrapper (HsExpr id) 
HsUnboundVar RdrName 


type LHsTupArg id = Located (HsTupArg id) Source

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


Present (LHsExpr id)

The argument

Missing (PostTc id Type)

The argument is missing, but this is its type


DataId id => Data (HsTupArg id) 

ppr_expr :: forall id. OutputableBndr id => HsExpr id -> SDoc Source

type LHsCmd id = Located (HsCmd id) Source

type LHsCmdTop id = Located (HsCmdTop id) 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.

data HsCmdTop id Source


HsCmdTop (LHsCmd id) (PostTc id Type) (PostTc id Type) (CmdSyntaxTable id) 


ppr_cmd :: forall id. OutputableBndr id => HsCmd id -> SDoc Source

data MatchGroup id body Source




mg_alts :: [LMatch id body]
mg_arg_tys :: [PostTc id Type]
mg_res_ty :: PostTc id Type
mg_origin :: Origin


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

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

May have AnnKeywordId : AnnSemi when in a list

data Match id body Source




m_fun_id_infix :: Maybe (Located id, Bool)
m_pats :: [LPat id]
m_type :: Maybe (LHsType id)
m_grhss :: GRHSs id body


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

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

data GRHSs id body Source

GRHSs are used both for pattern bindings and for Matches




grhssGRHSs :: [LGRHS id body]

Guarded RHSs

grhssLocalBinds :: HsLocalBinds id

The where clause


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

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

data GRHS id body Source

Guarded Right Hand Side.


GRHS [GuardLStmt id] body 


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

pprFunBind :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => idL -> Bool -> MatchGroup idR body -> SDoc Source

pprPatBind :: forall bndr id body. (OutputableBndr bndr, OutputableBndr id, Outputable body) => LPat bndr -> GRHSs id body -> SDoc Source

pprGRHS :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => HsMatchContext idL -> GRHS idR body -> SDoc Source

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

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

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

type Stmt id body = StmtLR id id body Source

type CmdLStmt id = LStmt id (LHsCmd id) Source

type CmdStmt id = Stmt id (LHsCmd id) Source

type ExprLStmt id = LStmt id (LHsExpr id) Source

type ExprStmt id = Stmt id (LHsExpr id) Source

type GuardLStmt id = LStmt id (LHsExpr id) Source

type GuardStmt id = Stmt id (LHsExpr id) Source

type GhciLStmt id = LStmt id (LHsExpr id) Source

type GhciStmt id = Stmt id (LHsExpr id) Source

data StmtLR idL idR body Source

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


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

data TransForm Source




data ParStmtBlock idL idR Source


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


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

pprStmt :: (OutputableBndr idL, OutputableBndr idR, Outputable body) => StmtLR idL idR body -> SDoc Source

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

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

pprDo :: (OutputableBndr id, Outputable body) => HsStmtContext any -> [LStmt id body] -> SDoc Source

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

pprComp :: (OutputableBndr id, Outputable body) => [LStmt id body] -> SDoc Source

pprQuals :: (OutputableBndr id, Outputable body) => [LStmt id body] -> SDoc Source

data HsSplice id Source


HsSplice id (LHsExpr id) 


data PendingSplice id Source


PendSplice Name (LHsExpr id) 

data HsBracket id Source


ExpBr (LHsExpr id) 
PatBr (LPat id) 
DecBrL [LHsDecl id] 
DecBrG (HsGroup id) 
TypBr (LHsType id) 
VarBr Bool id 
TExpBr (LHsExpr id) 


data ArithSeqInfo id Source


From (LHsExpr id) 
FromThen (LHsExpr id) (LHsExpr id) 
FromTo (LHsExpr id) (LHsExpr id) 
FromThenTo (LHsExpr id) (LHsExpr id) (LHsExpr id)