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

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

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 CoreSyn Note [CoreSyn let/app invariant]

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 CoreSyn Note [CoreSyn let/app invariant]

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

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

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

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

Create a CoreExpr which will evaluate to the given Word

Create a CoreExpr which will evaluate to the given Int

Create a CoreExpr which will evaluate to the given Int

Create a CoreExpr which will evaluate to the given Integer

Create a CoreExpr which will evaluate to the given Natural

TODO: should we add LitNatural to Core?

Create a CoreExpr which will evaluate to the given Float

Create a CoreExpr which will evaluate to the given Double

Create a CoreExpr which will evaluate to the given Char

Create a CoreExpr which will evaluate to the given String

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

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

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

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

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]

Make a core tuple of the given boxity

The unit expression

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

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

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

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

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 } |]

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

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.

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

Makes a list [] for lists of the specified type

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

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

Make a fully applied foldr expression

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

Makes a Nothing for the specified type

Makes a Just from a value of the specified type