GHC.PrimOps

Copy a range of the ArrayArray# to the specified region in the MutableArrayArray#. Both arrays must fully contain the specified ranges, but this is not checked. The two arrays must not be the same array in different states, but this is not checked either.

Copy a range of the first MutableArrayArray# to the specified region in the second MutableArrayArray#. Both arrays must fully contain the specified ranges, but this is not checked. The regions are allowed to overlap, although this is only possible when the same array is provided as both the source and the destination.

Create a new mutable array of arrays with the specified number of elements, in the specified state thread, with each element recursively referring to the newly created array.

Compare the underlying pointers of two arrays of arrays.

Compare the underlying pointers of two mutable arrays of arrays.

Return the number of elements in the array.

Return the number of elements in the array.

Make a mutable array of arrays immutable, without copying.

A list producer that can be fused with foldr. This function is merely

   augment g xs = g (:) xs

but GHC's simplifier will transform an expression of the form foldr k z (augment g xs), which may arise after inlining, to g k (foldr k z xs), which avoids producing an intermediate list.

A list producer that can be fused with foldr. This function is merely

   build g = g (:) []

but GHC's simplifier will transform an expression of the form foldr k z (build g), which may arise after inlining, to g k z, which avoids producing an intermediate list.

Shift the argument left by the specified number of bits (which must be non-negative).

Shift the argument right (signed) by the specified number of bits (which must be non-negative). The RA means "right, arithmetic" (as opposed to RL for logical)

Shift the argument right (unsigned) by the specified number of bits (which must be non-negative). The RL means "right, logical" (as opposed to RA for arithmetic)

Shift the argument left by the specified number of bits (which must be non-negative).

Shift the argument right by the specified number of bits (which must be non-negative). The RL means "right, logical" (as opposed to RA for arithmetic) (although an arithmetic right shift wouldn't make sense for Word#)

Compute the length of a NUL-terminated string. This address must refer to immutable memory. GHC includes a built-in rule for constant folding when the argument is a statically-known literal. That is, a core-to-core pass reduces the expression cstringLength# "hello"# to the constant 5#.

An implementation of the old atomicModifyMutVar# primop in terms of the new atomicModifyMutVar2# primop, for backwards compatibility. The type of this function is a bit bogus. It's best to think of it as having type

atomicModifyMutVar#
  :: MutVar# s a
  -> (a -> (a, b))
  -> State# s
  -> (# State# s, b #)

but there may be code that uses this with other two-field record types.

The groupWith function uses the user supplied function which projects an element out of every list element in order to first sort the input list and then to form groups by equality on these projected elements

Resize a mutable array to new specified size. The returned SmallMutableArray# is either the original SmallMutableArray# resized in-place or, if not possible, a newly allocated SmallMutableArray# with the original content copied over.

To avoid undefined behaviour, the original SmallMutableArray# shall not be accessed anymore after a resizeSmallMutableArray# has been performed. Moreover, no reference to the old one should be kept in order to allow garbage collection of the original SmallMutableArray# in case a new SmallMutableArray# had to be allocated.

The sortWith function sorts a list of elements using the user supplied function to project something out of each element

In general if the user supplied function is expensive to compute then you should probably be using sortOn, as it only needs to compute it once for each element. sortWith, on the other hand must compute the mapping function for every comparison that it performs.

the ensures that all the elements of the list are identical and then returns that unique element

The primitive used to implement GHC.IO.evaluate. Prefer to use GHC.IO.evaluate whenever possible!

Semantically, considerAccessible = True. But it has special meaning to the pattern-match checker, which will never flag the clause in which considerAccessible occurs as a guard as redundant or inaccessible. Example:

case (x, x) of
  (True,  True)  -> 1
  (False, False) -> 2
  (True,  False) -> 3 -- Warning: redundant

The pattern-match checker will warn here that the third clause is redundant. It will stop doing so if the clause is adorned with considerAccessible:

case (x, x) of
  (True,  True)  -> 1
  (False, False) -> 2
  (True,  False) | considerAccessible -> 3 -- No warning

Put considerAccessible as the last statement of the guard to avoid get confusing results from the pattern-match checker, which takes "consider accessible" by word.

The call inline f arranges that f is inlined, regardless of its size. More precisely, the call inline f rewrites to the right-hand side of f's definition. This allows the programmer to control inlining from a particular call site rather than the definition site of the function (c.f. INLINE pragmas).

This inlining occurs regardless of the argument to the call or the size of f's definition; it is unconditional. The main caveat is that f's definition must be visible to the compiler; it is therefore recommended to mark the function with an INLINABLE pragma at its definition so that GHC guarantees to record its unfolding regardless of size.

If no inlining takes place, the inline function expands to the identity function in Phase zero, so its use imposes no overhead.

Apply a function to a State# RealWorld token. When manually applying a function to realWorld#, it is necessary to use NOINLINE to prevent semantically undesirable floating. runRW# is inlined, but only very late in compilation after all floating is complete.

Retrieves the allocation counter for the current thread.

Compare two stable names for equality.

Compare the underlying pointers of two values for equality.

Returns 1 if the pointers are equal and 0 otherwise.

The two values must be of the same type, of kind Type. See also reallyUnsafePtrEquality#, which doesn't have such restrictions.

Compare the underlying pointers of two arrays.

Compare the pointers of two byte arrays.

Compare the underlying pointers of two MVar#s.

Compare the underlying pointers of two MutVar#s.

Compare the underlying pointers of two mutable arrays.

Compare the underlying pointers of two mutable byte arrays.

Compare the underlying pointers of two PromptTag#s.

Compare the underlying pointers of two small arrays.

Compare the underlying pointers of two small mutable arrays.

Compare the underlying pointers of two TVar#s.

Compare the underlying pointers of two unlifted values for equality.

This is less dangerous than reallyUnsafePtrEquality, since the arguments are guaranteed to be evaluated. This means there is no risk of accidentally comparing a thunk. It's however still more dangerous than e.g. sameArray#.

Returns a [String] representing the current call stack. This can be useful for debugging.

The implementation uses the call-stack simulation maintained by the profiler, so it only works if the program was compiled with -prof and contains suitable SCC annotations (e.g. by using -fprof-auto). Otherwise, the list returned is likely to be empty or uninformative.

Alias for tagToEnum#. Returns True if its parameter is 1# and False if it is 0#.

Highly, terribly dangerous coercion from one representation type to another. Misuse of this function can invite the garbage collector to trounce upon your data and then laugh in your face. You don't want this function. Really.

This becomes more obvious when looking at its actual type: forall (r1 :: RuntimeRep) (r2 :: RuntimeRep) (a :: TYPE r1) (b :: TYPE r2). a -> b Which often get's rendered as a -> b in haddock for technical reasons.

The lazy function restrains strictness analysis a little. The call lazy e means the same as e, but lazy has a magical property so far as strictness analysis is concerned: it is lazy in its first argument, even though its semantics is strict. After strictness analysis has run, calls to lazy are inlined to be the identity function.

This behaviour is occasionally useful when controlling evaluation order. Notably, lazy is used in the library definition of Control.Parallel.par:

par :: a -> b -> b
par x y = case (par# x) of _ -> lazy y

If lazy were not lazy, Control.Parallel.par would look strict in y which would defeat the whole purpose of Control.Parallel.par.

The call noinline f arranges that f will not be inlined. It is removed during CorePrep so that its use imposes no overhead (besides the fact that it blocks inlining.)

The oneShot function can be used to give a hint to the compiler that its argument will be called at most once, which may (or may not) enable certain optimizations. It can be useful to improve the performance of code in continuation passing style.

If oneShot is used wrongly, then it may be that computations whose result that would otherwise be shared are re-evaluated every time they are used. Otherwise, the use of oneShot is safe.

oneShot is representation-polymorphic: the type variables may refer to lifted or unlifted types.

Low word of signed integer multiply.

Exponentiation.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

Element-wise absolute value.

addCFinalizerToWeak# fptr ptr flag eptr w attaches a C function pointer fptr to a weak pointer w as a finalizer. If flag is zero, fptr will be called with one argument, ptr. Otherwise, it will be called with two arguments, eptr and ptr. addCFinalizerToWeak# returns 1 on success, or 0 if w is already dead.

Add signed integers reporting overflow. First member of result is the sum truncated to an Int#; second member is zero if the true sum fits in an Int#, nonzero if overflow occurred (the sum is either too large or too small to fit in an Int#).

Add unsigned integers reporting overflow. The first element of the pair is the result. The second element is the carry flag, which is nonzero on overflow. See also plusWord2#.

Coerce directly from address to int. Users are discouraged from using this operation as it makes little sense on platforms with tagged pointers.

Convert an Addr# to a followable Any type.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bitwise "and".

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.

Bit-wise AND of two vectors.