ghc-7.8.4: The GHC API

Safe HaskellNone
LanguageHaskell98

MkCore

Contents

Description

Handy functions for creating much Core syntax

Synopsis

Constructing normal syntax

mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr Source

Bind a binding group over an expression, using a let or case as appropriate (see CoreSyn)

mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr Source

Bind a list of binding groups over an expression. The leftmost binding group becomes the outermost group in the resulting expression

mkCoreApp :: CoreExpr -> CoreExpr -> CoreExpr infixl 4 Source

Construct an expression which represents the application of one expression to the other

mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr infixl 4 Source

Construct an expression which represents the application of a number of expressions to another. The leftmost expression in the list is applied first

mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr Source

Construct an expression which represents the application of a number of expressions to that of a data constructor expression. The leftmost expression in the list is applied first

mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr Source

Create a lambda where the given expression has a number of variables bound over it. The leftmost binder is that bound by the outermost lambda in the result

mkWildCase :: CoreExpr -> Type -> Type -> [CoreAlt] -> CoreExpr Source

mkIfThenElse :: CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr Source

mkWildValBinder :: Type -> Id Source

Make a wildcard binder. This is typically used when you need a binder that you expect to use only at a *binding* site. Do not use it at occurrence sites because it has a single, fixed unique, and it's very easy to get into difficulties with shadowing. That's why it is used so little. See Note [WildCard binders] in SimplEnv

mkWildEvBinder :: PredType -> EvVar Source

sortQuantVars :: [Var] -> [Var] Source

castBottomExpr :: CoreExpr -> Type -> CoreExpr Source

Constructing boxed literals

mkWordExpr :: DynFlags -> Integer -> CoreExpr Source

Create a CoreExpr which will evaluate to the a Word with the given value

mkWordExprWord :: DynFlags -> Word -> CoreExpr Source

Create a CoreExpr which will evaluate to the given Word

mkIntExpr :: DynFlags -> Integer -> CoreExpr Source

Create a CoreExpr which will evaluate to the given Int

mkIntExprInt :: DynFlags -> Int -> CoreExpr Source

Create a CoreExpr which will evaluate to the given Int

mkIntegerExpr :: MonadThings m => Integer -> m CoreExpr Source

Create a CoreExpr which will evaluate to the given Integer

mkFloatExpr :: Float -> CoreExpr Source

Create a CoreExpr which will evaluate to the given Float

mkDoubleExpr :: Double -> CoreExpr Source

Create a CoreExpr which will evaluate to the given Double

mkCharExpr :: Char -> CoreExpr Source

Create a CoreExpr which will evaluate to the given Char

mkStringExpr :: MonadThings m => String -> m CoreExpr Source

Create a CoreExpr which will evaluate to the given String

mkStringExprFS :: MonadThings m => FastString -> m CoreExpr Source

Create a CoreExpr which will evaluate to a string morally equivalent to the given FastString

Floats

data FloatBind Source

Constructors

FloatLet CoreBind 
FloatCase CoreExpr Id AltCon [Var] 

Instances

wrapFloat :: FloatBind -> CoreExpr -> CoreExpr Source

Constructing equality evidence boxes

mkEqBox :: Coercion -> CoreExpr Source

Constructing general big tuples

GHCs built in tuples can only go up to mAX_TUPLE_SIZE in arity, but we might concievably want to build such a massive tuple as part of the output of a desugaring stage (notably that for list comprehensions).

We call tuples above this size "big tuples", and emulate them by creating and pattern matching on >nested< tuples that are expressible by GHC.

Nesting policy: it's better to have a 2-tuple of 10-tuples (3 objects) than a 10-tuple of 2-tuples (11 objects), so we want the leaves of any construction to be big.

If you just use the mkBigCoreTup, mkBigCoreVarTupTy, mkTupleSelector and mkTupleCase functions to do all your work with tuples you should be fine, and not have to worry about the arity limitation at all.

mkChunkified Source

Arguments

:: ([a] -> a)

"Small" constructor function, of maximum input arity mAX_TUPLE_SIZE

-> [a]

Possible "big" list of things to construct from

-> a

Constructed thing made possible by recursive decomposition

Lifts a "small" constructor into a "big" constructor by recursive decompositon

Constructing small tuples

mkCoreVarTup :: [Id] -> CoreExpr Source

Build a small tuple holding the specified variables

mkCoreVarTupTy :: [Id] -> Type Source

Bulid the type of a small tuple that holds the specified variables

mkCoreTup :: [CoreExpr] -> CoreExpr Source

Build a small tuple holding the specified expressions

Constructing big tuples

mkBigCoreVarTup :: [Id] -> CoreExpr Source

Build a big tuple holding the specified variables

mkBigCoreVarTupTy :: [Id] -> Type Source

Build the type of a big tuple that holds the specified variables

mkBigCoreTup :: [CoreExpr] -> CoreExpr Source

Build a big tuple holding the specified expressions

mkBigCoreTupTy :: [Type] -> Type Source

Build the type of a big tuple that holds the specified type of thing

Deconstructing small tuples

mkSmallTupleSelector :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr Source

Like mkTupleSelector but for tuples that are guaranteed never to be "big".

mkSmallTupleSelector [x] x v e = [| e |]
mkSmallTupleSelector [x,y,z] x v e = [| case e of v { (x,y,z) -> x } |]

mkSmallTupleCase Source

Arguments

:: [Id]

The tuple args

-> CoreExpr

Body of the case

-> Id

A variable of the same type as the scrutinee

-> CoreExpr

Scrutinee

-> CoreExpr 

As mkTupleCase, but for a tuple that is small enough to be guaranteed not to need nesting.

Deconstructing big tuples

mkTupleSelector Source

Arguments

:: [Id]

The Ids to pattern match the tuple against

-> Id

The Id to select

-> Id

A variable of the same type as the scrutinee

-> CoreExpr

Scrutinee

-> CoreExpr

Selector expression

Builds a selector which scrutises the given expression and extracts the one name from the list given. If you want the no-shadowing rule to apply, the caller is responsible for making sure that none of these names are in scope.

If there is just one Id in the tuple, then the selector is just the identity.

If necessary, we pattern match on a "big" tuple.

mkTupleCase Source

Arguments

:: UniqSupply

For inventing names of intermediate variables

-> [Id]

The tuple identifiers to pattern match on

-> CoreExpr

Body of the case

-> Id

A variable of the same type as the scrutinee

-> CoreExpr

Scrutinee

-> CoreExpr 

A generalization of mkTupleSelector, allowing the body of the case to be an arbitrary expression.

To avoid shadowing, we use uniques to invent new variables.

If necessary we pattern match on a "big" tuple.

Constructing list expressions

mkNilExpr :: Type -> CoreExpr Source

Makes a list [] for lists of the specified type

mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr Source

Makes a list (:) for lists of the specified type

mkListExpr :: Type -> [CoreExpr] -> CoreExpr Source

Make a list containing the given expressions, where the list has the given type

mkFoldrExpr Source

Arguments

:: MonadThings m 
=> Type

Element type of the list

-> Type

Fold result type

-> CoreExpr

Cons function expression for the fold

-> CoreExpr

Nil expression for the fold

-> CoreExpr

List expression being folded acress

-> m CoreExpr 

Make a fully applied foldr expression

mkBuildExpr Source

Arguments

:: (MonadThings m, MonadUnique m) 
=> Type

Type of list elements to be built

-> ((Id, Type) -> (Id, Type) -> m CoreExpr)

Function that, given information about the Ids of the binders for the build worker function, returns the body of that worker

-> m CoreExpr 

Make a build expression applied to a locally-bound worker function

Error Ids

mkRuntimeErrorApp :: Id -> Type -> String -> CoreExpr Source

mkImpossibleExpr :: Type -> CoreExpr Source

errorIds :: [Id] Source

rEC_CON_ERROR_ID :: Id Source

iRREFUT_PAT_ERROR_ID :: Id Source

rUNTIME_ERROR_ID :: Id Source

nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id Source

nO_METHOD_BINDING_ERROR_ID :: Id Source

pAT_ERROR_ID :: Id Source

eRROR_ID :: Id Source

rEC_SEL_ERROR_ID :: Id Source

aBSENT_ERROR_ID :: Id Source

uNDEFINED_ID :: Id Source

undefinedName :: Name Source