Main data type

So-called Literals are one of:

• An unboxed (machine) literal (MachInt, MachFloat, etc.), which is presumed to be surrounded by appropriate constructors (Int#, etc.), so that the overall thing makes sense.

We maintain the invariant that the Integer the Mach{Int,Word}* constructors are actually in the (possibly target-dependent) range. The mkMach{Int,Word}*Wrap smart constructors ensure this by applying the target machine's wrapping semantics. Use these in situations where you know the wrapping semantics are correct.

• The literal derived from the label mentioned in a "foreign label" declaration (MachLabel)

Numeric literal type

Creates a Literal of type Int#

Creates a Literal of type Int#. If the argument is out of the (target-dependent) range, it is wrapped. See Note [WordInt underflowoverflow]

Creates a Literal of type Int#, as well as a Boolean flag indicating overflow. That is, if the argument is out of the (target-dependent) range the argument is wrapped and the overflow flag will be set. See Note [WordInt underflowoverflow]

Creates a Literal of type Word#

Creates a Literal of type Word#. If the argument is out of the (target-dependent) range, it is wrapped. See Note [WordInt underflowoverflow]

Creates a Literal of type Word#, as well as a Boolean flag indicating carry. That is, if the argument is out of the (target-dependent) range the argument is wrapped and the carry flag will be set. See Note [WordInt underflowoverflow]

Creates a Literal of type Int64#

Creates a Literal of type Int64#. If the argument is out of the range, it is wrapped.

Creates a Literal of type Word64#

Creates a Literal of type Word64#. If the argument is out of the range, it is wrapped.

Creates a Literal of type Float#

Creates a Literal of type Double#

Creates a Literal of type Char#

Creates a Literal of type Addr#, which is appropriate for passing to e.g. some of the "error" functions in GHC.Err such as GHC.Err.runtimeError

Create a numeric Literal of the given type

Create a numeric Literal of the given type

Find the Haskell Type the literal occupies

Indicate if a numeric literal type supports negative numbers

Check that a given number is in the range of a numeric literal

True if code space does not go bad if we duplicate this literal

True if there is absolutely no penalty to duplicating the literal. False principally of strings.

"Why?", you say? I'm glad you asked. Well, for one duplicating strings would blow up code sizes. Not only this, it's also unsafe.

Consider a program that wants to traverse a string. One way it might do this is to first compute the Addr# pointing to the end of the string, and then, starting from the beginning, bump a pointer using eqAddr# to determine the end. For instance,

-- Given pointers to the start and end of a string, count how many zeros
-- the string contains.
countZeros :: Addr -> -> Int
countZeros start end = go start 0
  where
    go off n
      | off `addrEq#` end = n
      | otherwise         = go (off `plusAddr#` 1) n'
      where n' | isTrue off 0 0#) = n + 1
               | otherwise                                 = n

Consider what happens if we considered strings to be trivial (and therefore duplicable) and emitted a call like countZeros "hello" plusAddr# 5). The beginning and end pointers do not belong to the same string, meaning that an iteration like the above would blow up terribly. This is what happened in #12757.

Ultimately the solution here is to make primitive strings a bit more structured, ensuring that the compiler can't inline in ways that will break user code. One approach to this is described in #8472.

Tests whether the literal represents a zero of whatever type it is

Returns the Integer contained in the Literal, for when that makes sense, i.e. for Char, Int, Word, LitInteger and LitNatural.

Indicate if the Literal contains an Integer value, e.g. Char, Int, Word, LitInteger and LitNatural.

Returns the Integer contained in the Literal, for when that makes sense, i.e. for Char and numbers.

Apply a function to the Integer contained in the Literal, for when that makes sense, e.g. for Char and numbers. For fixed-size integral literals, the result will be wrapped in accordance with the semantics of the target type. See Note [WordInt underflowoverflow]

Narrow a literal number (unchecked result range)