ghc-7.10.1: The GHC API

Safe HaskellNone




data HsLocalBindsLR idL idR Source

Bindings in a 'let' expression or a 'where' clause


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

data HsValBindsLR idL idR Source

Value bindings (not implicit parameters) Used for both top level and nested bindings May contain pattern synonym bindings


ValBindsIn (LHsBindsLR idL idR) [LSig idR]

Before renaming RHS; idR is always RdrName Not dependency analysed Recursive by default

ValBindsOut [(RecFlag, LHsBinds idL)] [LSig Name]

After renaming RHS; idR can be Name or Id Dependency analysed, later bindings in the list may depend on earlier ones.


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

type LHsBind id = LHsBindLR id id Source

type LHsBinds id = LHsBindsLR id id Source

type HsBind id = HsBindLR id id Source

type LHsBindsLR idL idR = Bag (LHsBindLR idL idR) Source

type LHsBindLR idL idR = Located (HsBindLR idL idR) Source

data HsBindLR idL idR Source



FunBind is used for both functions f x = e and variables f = x -> e

Reason 1: Special case for type inference: see tcMonoBinds.

Reason 2: Instance decls can only have FunBinds, which is convenient. If you change this, you'll need to change e.g. rnMethodBinds

But note that the form f :: a->a = ... parses as a pattern binding, just like (f :: a -> a) = ...



fun_id :: Located idL
fun_infix :: Bool

True => infix declaration

fun_matches :: MatchGroup idR (LHsExpr idR)

The payload

fun_co_fn :: HsWrapper

Coercion from the type of the MatchGroup to the type of the Id. Example:

     f :: Int -> forall a. a -> a
     f x y = y

Then the MatchGroup will have type (Int -> a' -> a') (with a free type variable a'). The coercion will take a CoreExpr of this type and convert it to a CoreExpr of type Int -> forall a'. a' -> a' Notice that the coercion captures the free a'.

bind_fvs :: PostRn idL NameSet

After the renamer, this contains the locally-bound free variables of this defn. See Note [Bind free vars]

fun_tick :: [Tickish Id]

Ticks to put on the rhs, if any


The pattern is never a simple variable; That case is done by FunBind


pat_lhs :: LPat idL
pat_rhs :: GRHSs idR (LHsExpr idR)
pat_rhs_ty :: PostTc idR Type

Type of the GRHSs

bind_fvs :: PostRn idL NameSet

After the renamer, this contains the locally-bound free variables of this defn. See Note [Bind free vars]

pat_ticks :: ([Tickish Id], [[Tickish Id]])

Ticks to put on the rhs, if any, and ticks to put on the bound variables.


Dictionary binding and suchlike. All VarBinds are introduced by the type checker


var_id :: idL
var_rhs :: LHsExpr idR

Located only for consistency

var_inline :: Bool

True = inline this binding regardless (used for implication constraints only)



abs_tvs :: [TyVar]
abs_ev_vars :: [EvVar]

Includes equality constraints

abs_exports :: [ABExport idL]

AbsBinds only gets used when idL = idR after renaming, but these need to be idL's for the collect... code in HsUtil to have the right type

abs_ev_binds :: TcEvBinds

Evidence bindings

abs_binds :: LHsBinds idL

Typechecked user bindings

PatSynBind (PatSynBind idL idR)


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

data ABExport id Source




abe_poly :: id

Any INLINE pragmas is attached to this Id

abe_mono :: id
abe_wrap :: HsWrapper

See Note [AbsBinds wrappers] Shape: (forall abs_tvs. abs_ev_vars => abe_mono) ~ abe_poly

abe_prags :: TcSpecPrags



data PatSynBind idL idR Source




psb_id :: Located idL

Name of the pattern synonym

psb_fvs :: PostRn idR NameSet

See Note [Bind free vars]

psb_args :: HsPatSynDetails (Located idR)

Formal parameter names

psb_def :: LPat idR

Right-hand side

psb_dir :: HsPatSynDir idR



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

data HsIPBinds id Source


IPBinds [LIPBind id] TcEvBinds 


type LIPBind id = Located (IPBind id) Source

May have AnnKeywordId : AnnSemi when in a list

data IPBind id Source

Implicit parameter bindings.

These bindings start off as (Left "x") in the parser and stay that way until after type-checking when they are replaced with (Right d), where "d" is the name of the dictionary holding the evidence for the implicit parameter.


IPBind (Either (Located HsIPName) id) (LHsExpr id) 


DataId name => Data (IPBind name) 
OutputableBndr id => Outputable (IPBind id) 

type LSig name = Located (Sig name) Source

data Sig name Source

Signatures and pragmas


TypeSig [Located name] (LHsType name) (PostRn name [Name])

An ordinary type signature

f :: Num a => a -> a

After renaming, this list of Names contains the named and unnamed wildcards brought into scope by this signature. For a signature _ -> _a -> Bool, the renamer will give the unnamed wildcard _ a freshly generated name, e.g. _w. _w and the named wildcard _a are then both replaced with fresh meta vars in the type. Their names are stored in the type signature that brought them into scope, in this third field to be more specific.

PatSynSig (Located name) (HsExplicitFlag, LHsTyVarBndrs name) (LHsContext name) (LHsContext name) (LHsType name)

A pattern synonym type signature

pattern Single :: () => (Show a) => a -> [a]
GenericSig [Located name] (LHsType name)

A type signature for a default method inside a class

default eq :: (Representable0 a, GEq (Rep0 a)) => a -> a -> Bool
IdSig Id

A type signature in generated code, notably the code generated for record selectors. We simply record the desired Id itself, replete with its name, type and IdDetails. Otherwise it's just like a type signature: there should be an accompanying binding

FixSig (FixitySig name)

An ordinary fixity declaration

    infixl 8 ***
InlineSig (Located name) InlinePragma

An inline pragma

{#- INLINE f #-}
SpecSig (Located name) [LHsType name] InlinePragma

A specialisation pragma

{-# SPECIALISE f :: Int -> Int #-}
SpecInstSig SourceText (LHsType name)

A specialisation pragma for instance declarations only

{-# SPECIALISE instance Eq [Int] #-}

(Class tys); should be a specialisation of the current instance declaration

MinimalSig SourceText (BooleanFormula (Located name))

A minimal complete definition pragma

{-# MINIMAL a | (b, c | (d | e)) #-}


DataId name => Data (Sig name) 
OutputableBndr name => Outputable (Sig name) 

type LFixitySig name = Located (FixitySig name) Source

data FixitySig name Source


FixitySig [Located name] Fixity 


Data name => Data (FixitySig name) 
OutputableBndr name => Outputable (FixitySig name) 

data TcSpecPrags Source

TsSpecPrags conveys pragmas from the type checker to the desugarer



Super-specialised: a default method should be macro-expanded at every call site

SpecPrags [LTcSpecPrag] 


data TcSpecPrag Source


SpecPrag Id HsWrapper InlinePragma

The Id to be specialised, an wrapper that specialises the polymorphic function, and inlining spec for the specialised function

hsSigDoc :: Sig name -> SDoc Source

ppr_sig :: OutputableBndr name => Sig name -> SDoc Source

pprPatSynSig :: OutputableBndr name => name -> Bool -> SDoc -> Maybe SDoc -> Maybe SDoc -> SDoc -> SDoc Source