Documentation

Create a new small mutable array.

Note: this function does not check if the input is non-negative.

Read the element at a given index in a mutable array.

Note: this function does not do bounds checking.

Write an element at the given idex in a mutable array.

Note: this function does not do bounds checking.

Copy a slice of an immutable array into a mutable array.

Note: this function does not do bounds or overlap checking.

Copy a slice of one mutable array into another.

Note: this function does not do bounds or overlap checking.

Look up an element in an immutable array.

Note: this function does not do bounds checking.

Look up an element in an immutable array.

The purpose of returning a result using an applicative is to allow the caller to avoid retaining references to the array. Evaluating the return value will cause the array lookup to be performed, even though it may not require the element of the array to be evaluated (which could throw an exception). For instance:

data Box a = Box a
...

f sa = case indexSmallArrayM sa 0 of
  Box x -> ...

x is not a closure that references sa as it would be if we instead wrote:

let x = indexSmallArray sa 0

It also does not prevent sa from being garbage collected.

Note that Identity is not adequate for this use, as it is a newtype, and cannot be evaluated without evaluating the element.

Note: this function does not do bounds checking.

Read a value from the immutable array at the given index, returning the result in an unboxed unary tuple. This is currently used to implement folds.

Note: this function does not do bounds checking.

Create a copy of a slice of an immutable array.

Note: The provided array should contain the full subrange specified by the two Ints, but this is not checked.

Create a copy of a slice of a mutable array.

Note: The provided array should contain the full subrange specified by the two Ints, but this is not checked.

Create an immutable array corresponding to a slice of a mutable array.

This operation copies the portion of the array to be frozen.

Note: The provided array should contain the full subrange specified by the two Ints, but this is not checked.

Render a mutable array immutable.

This operation performs no copying, so care must be taken not to modify the input array after freezing.

Create a mutable array corresponding to a slice of an immutable array.

This operation copies the portion of the array to be thawed.

Note: The provided array should contain the full subrange specified by the two Ints, but this is not checked.

Render an immutable array mutable.

This operation performs no copying, so care must be taken with its use.

Execute the monadic action and freeze the resulting array.

runSmallArray m = runST $ m >>= unsafeFreezeSmallArray

Create an array of the given size with a default value, apply the monadic function and freeze the result. If the size is 0, return emptySmallArray (rather than a new copy thereof).

createSmallArray 0 _ _ = emptySmallArray
createSmallArray n x f = runSmallArray $ do
  mary <- newSmallArray n x
  f mary
  pure mary

The number of elements in an immutable array.

Get the number of elements in a mutable array. Unlike sizeofSmallMutableArray, this function will be sure to produce the correct result if SmallMutableArray has been shrunk in place. Consider the following:

do
  sa <- newSmallArray 10 x
  print $ sizeofSmallMutableArray sa
  shrinkSmallMutableArray sa 5
  print $ sizeofSmallMutableArray sa

The compiler is well within its rights to eliminate the second size check and print 10 twice. However, getSizeofSmallMutableArray will check the size each time it's executed (not evaluated), so it won't have this problem:

do
  sa <- newSmallArray 10 x
  print =<< getSizeofSmallMutableArray sa
  shrinkSmallMutableArray sa 5
  print =<< getSizeofSmallMutableArray sa

will certainly print 10 and then 5.

The number of elements in a mutable array. This should only be used for arrays that are not shrunk in place.

This is deprecated and will be removed in a future release. Use getSizeofSmallMutableArray instead.

Shrink the mutable array in place. The size given must be equal to or less than the current size of the array. This is not checked.

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

Create a SmallArray from a list.

Create a SmallArray from a list of a known length. If the length of the list does not match the given length, this throws an exception.

Strict map over the elements of the array.

This is the fastest, most straightforward way to traverse an array, but it only works correctly with a sufficiently "affine" PrimMonad instance. In particular, it must only produce one result array. ListT-transformed monads, for example, will not work right at all.