ghc-9.2.0.20210331: The GHC API
Safe HaskellSafe-Inferred
LanguageHaskell2010

GHC.Core.Make

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

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 :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr infixl 4 Source #

Construct an expression which represents the application of one expression to the other Respects the let/app invariant by building a case expression where necessary See Note [Core let/app invariant] in GHC.Core

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 Respects the let/app invariant by building a case expression where necessary See Note [Core let/app invariant] in GHC.Core

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

mkWildValBinder :: Mult -> 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 GHC.Core.Opt.Simplify.Env

Constructing boxed literals

mkWordExpr :: Platform -> Integer -> CoreExpr Source #

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

mkIntExpr :: Platform -> Integer -> CoreExpr Source #

Create a CoreExpr which will evaluate to the given Int

mkIntExprInt :: Platform -> Int -> CoreExpr Source #

Create a CoreExpr which will evaluate to the given Int

mkUncheckedIntExpr :: Integer -> CoreExpr Source #

Create a CoreExpr which will evaluate to the given Int. Don't check that the number is in the range of the target platform Int

mkIntegerExpr :: Integer -> CoreExpr Source #

Create a CoreExpr which will evaluate to the given Integer

mkNaturalExpr :: Integer -> CoreExpr Source #

Create a CoreExpr which will evaluate to the given Natural

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 #

Instances

Instances details
Outputable FloatBind # 
Instance details

Defined in GHC.Core.Make

Methods

ppr :: FloatBind -> SDoc Source #

wrapFloats :: [FloatBind] -> CoreExpr -> CoreExpr Source #

Applies the floats from right to left. That is wrapFloats [b1, b2, …, bn] u = let b1 in let b2 in … in let bn in u

Constructing small tuples

mkCoreVarTupTy :: [Id] -> Type Source #

Build the type of a small tuple that holds the specified variables One-tuples are flattened; see Note [Flattening one-tuples]

mkCoreTup :: [CoreExpr] -> CoreExpr Source #

Build a small tuple holding the specified expressions One-tuples are flattened; see Note [Flattening one-tuples]

mkCoreUbxTup :: [Type] -> [CoreExpr] -> CoreExpr Source #

Build a small unboxed tuple holding the specified expressions, with the given types. The types must be the types of the expressions. Do not include the RuntimeRep specifiers; this function calculates them for you. Does not flatten one-tuples; see Note [Flattening one-tuples]

mkCoreUbxSum :: Int -> Int -> [Type] -> CoreExpr -> CoreExpr Source #

Build an unboxed sum.

Alternative number ("alt") starts from 1.

mkCoreTupBoxity :: Boxity -> [CoreExpr] -> CoreExpr Source #

Make a core tuple of the given boxity; don't flatten 1-tuples

unitExpr :: CoreExpr Source #

The unit expression

Constructing big tuples

mkBigCoreVarTup :: [Id] -> CoreExpr Source #

Build a big tuple holding the specified variables One-tuples are flattened; see Note [Flattening one-tuples]

mkBigCoreVarTupTy :: [Id] -> Type Source #

Build the type of a big tuple that holds the specified variables One-tuples are flattened; see Note [Flattening one-tuples]

mkBigCoreTupTy :: [Type] -> Type Source #

Build the type of a big tuple that holds the specified type of thing One-tuples are flattened; see Note [Flattening one-tuples]

mkBigCoreTup :: [CoreExpr] -> CoreExpr Source #

Build a big tuple holding the specified expressions One-tuples are flattened; see Note [Flattening one-tuples]

Deconstructing small tuples

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

mkSmallTupleSelector1 is like mkSmallTupleSelector but one-tuples are NOT flattened (see Note [Flattening one-tuples])

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

mkTupleSelector1 is like mkTupleSelector but one-tuples are NOT flattened (see Note [Flattening one-tuples])

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.

A tuple selector is not linear in its argument. Consequently, the case expression built by mkTupleSelector must consume its scrutinee Many times. And all the argument variables must have multiplicity Many.

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

A tuple selector is not linear in its argument. Consequently, the case expression built by mkTupleSelector must consume its scrutinee Many times. And all the argument variables must have multiplicity Many.

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

:: (MonadFail m, 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

Constructing Maybe expressions

mkNothingExpr :: Type -> CoreExpr Source #

Makes a Nothing for the specified type

mkJustExpr :: Type -> CoreExpr -> CoreExpr Source #

Makes a Just from a value of the specified type

Error Ids