Arrays of unboxed elements. This accepts types like Double, Char, Int, and Word, as well as their fixed-length variants (Word8, Word16, etc.). Since the elements are unboxed, a PrimArray is strict in its elements. This differs from the behavior of Array, which is lazy in its elements.

Mutable primitive arrays associated with a primitive state token. These can be written to and read from in a monadic context that supports sequencing such as IO or ST. Typically, a mutable primitive array will be built and then convert to an immutable primitive array using unsafeFreezePrimArray. However, it is also acceptable to simply discard a mutable primitive array since it lives in managed memory and will be garbage collected when no longer referenced.

Create a new mutable primitive array of the given length. The underlying memory is left uninitialized.

Resize a mutable primitive array. The new size is given in elements.

This will either resize the array in-place or, if not possible, allocate the contents into a new, unpinned array and copy the original array's contents.

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

Shrink a mutable primitive array. The new size is given in elements. It must be smaller than the old size. The array will be resized in place. This function is only available when compiling with GHC 7.10 or newer.

Write an element to the given index.

Read a primitive value from the primitive array.

Convert a mutable byte array to an immutable one without copying. The array should not be modified after the conversion.

Convert an immutable array to a mutable one without copying. The original array should not be used after the conversion.

Copy part of an array into another mutable array.

Copy part of a mutable array into another mutable array. In the case that the destination and source arrays are the same, the regions may overlap.

Copy a slice of an immutable primitive array to an address. The offset and length are given in elements of type a. This function assumes that the Prim instance of a agrees with the Storable instance. This function is only available when building with GHC 7.8 or newer.

Copy a slice of an immutable primitive array to an address. The offset and length are given in elements of type a. This function assumes that the Prim instance of a agrees with the Storable instance. This function is only available when building with GHC 7.8 or newer.

Fill a slice of a mutable primitive array with a value.

Check if the two arrays refer to the same memory block.

Get the size of a mutable primitive array in elements. Unlike sizeofMutablePrimArray, this function ensures sequencing in the presence of resizing.

Size of the mutable primitive array in elements. This function shall not be used on primitive arrays that are an argument to or a result of resizeMutablePrimArray or shrinkMutablePrimArray.

Get the size, in elements, of the primitive array.

Convert the primitive array to a list.

Lazy right-associated fold over the elements of a PrimArray.

Strict right-associated fold over the elements of a PrimArray.

Lazy left-associated fold over the elements of a PrimArray.

Strict left-associated fold over the elements of a PrimArray.

Strict left-associated fold over the elements of a PrimArray.

Traverse the primitive array, discarding the results. There is no PrimMonad variant of this function since it would not provide any performance benefit.

Traverse the primitive array with the indices, discarding the results. There is no PrimMonad variant of this function since it would not provide any performance benefit.

Map over the elements of a primitive array.

Indexed map over the elements of a primitive array.

Generate a primitive array.

Create a primitive array by copying the element the given number of times.

Filter elements of a primitive array according to a predicate.

Map over a primitive array, optionally discarding some elements. This has the same behavior as Data.Maybe.mapMaybe.

Traverse a primitive array. The traversal performs all of the applicative effects before forcing the resulting values and writing them to the new primitive array. Consequently:

>>> traversePrimArray (\x -> print x $> bool x undefined (x == 2)) (fromList [1, 2, 3 :: Int])
1
2
3
*** Exception: Prelude.undefined

The function traversePrimArrayP always outperforms this function, but it requires a PrimMonad constraint, and it forces the values as it performs the effects.

Traverse a primitive array with the index of each element.

Generate a primitive array by evaluating the applicative generator function at each index.

Execute the applicative action the given number of times and store the results in a vector.

Filter the primitive array, keeping the elements for which the monadic predicate evaluates true.

Map over the primitive array, keeping the elements for which the applicative predicate provides a Just.

Traverse a primitive array. The traversal forces the resulting values and writes them to the new primitive array as it performs the monadic effects. Consequently:

>>> traversePrimArrayP (\x -> print x $> bool x undefined (x == 2)) (fromList [1, 2, 3 :: Int])
1
2
*** Exception: Prelude.undefined

In many situations, traversePrimArrayP can replace traversePrimArray, changing the strictness characteristics of the traversal but typically improving the performance. Consider the following short-circuiting traversal:

incrPositiveA :: PrimArray Int -> Maybe (PrimArray Int)
incrPositiveA xs = traversePrimArray (\x -> bool Nothing (Just (x + 1)) (x > 0)) xs

This can be rewritten using traversePrimArrayP. To do this, we must change the traversal context to MaybeT (ST s), which has a PrimMonad instance:

incrPositiveB :: PrimArray Int -> Maybe (PrimArray Int)
incrPositiveB xs = runST $ runMaybeT $ traversePrimArrayP
  (\x -> bool (MaybeT (return Nothing)) (MaybeT (return (Just (x + 1)))) (x > 0))
  xs

Benchmarks demonstrate that the second implementation runs 150 times faster than the first. It also results in fewer allocations.

Traverse a primitive array with the indices. The traversal forces the resulting values and writes them to the new primitive array as it performs the monadic effects.

Generate a primitive array by evaluating the monadic generator function at each index.

Execute the monadic action the given number of times and store the results in a primitive array.

Filter the primitive array, keeping the elements for which the monadic predicate evaluates true.

Map over the primitive array, keeping the elements for which the monadic predicate provides a Just.