The size of the array

The size of the mutable array

Test whether the array is empty.

Index into an array at the given index.

Index into an array at the given index, yielding an unboxed one-tuple of the element.

Read a mutable array at the given index.

Indexing in a monad.

The monad allows operations to be strict in the array when necessary. Suppose array copying is implemented like this:

copy mv v = ... write mv i (v ! i) ...

For lazy arrays, v ! i would not be not be evaluated, which means that mv would unnecessarily retain a reference to v in each element written.

With indexM, copying can be implemented like this instead:

copy mv v = ... do
  x <- indexM v i
  write mv i x

Here, no references to v are retained because indexing (but not the elements) is evaluated eagerly.

The empty array.

Allocate a new mutable array of the given size.

Create a singleton array.

Create a doubleton array.

Create a tripleton array.

Create a quadrupleton array.

replicate n x is an array of length n with x the value of every element.

replicateMut n x is a mutable array of length n with x the value of every element.

Construct an array of the given length by applying the function to each index.

Construct an array of the given length by applying the monadic action to each index.

Construct a mutable array of the given length by applying the function to each index.

Apply a function n times to a value and construct an array where each consecutive element is the result of an additional application of this function. The zeroth element is the original value.

iterateN 5 (+ 1) 0 = fromListN 5 [0,1,2,3,4]

Apply a function n times to a value and construct a mutable array where each consecutive element is the result of an additional application of this function. The zeroth element is the original value.

Write to a mutable array at the given index.

Run an effectful computation that produces an array.

replicateMutM n act performs the action n times, gathering the results.

Construct a mutable array of the given length by applying the monadic action to each index.

Apply a monadic function n times to a value and construct a mutable array where each consecutive element is the result of an additional application of this function. The zeroth element is the original value.

Execute the monad action and freeze the resulting array.

Execute the monadic action and freeze the resulting array.

Construct an array by repeatedly applying a generator function to a seed. The generator function yields Just the next element and the new seed or Nothing if there are no more elements.

>>> unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1) 10
    <10,9,8,7,6,5,4,3,2,1>

Construct an array with at most n elements by repeatedly applying the generator function to a seed. The generator function yields Just the next element and the new seed or Nothing if there are no more elements.

Construct a mutable array by repeatedly applying a generator function to a seed. The generator function yields Just the next element and the new seed or Nothing if there are no more elements.

>>> unfoldrMutable (\n -> if n == 0 then Nothing else Just (n,n-1) 10
    <10,9,8,7,6,5,4,3,2,1>

Yield an array of the given length containing the values x, succ x, succ (succ x) etc.

Yield a mutable array of the given length containing the values x, succ x, succ (succ x) etc.

Append two arrays.

Copy a slice of an array and then insert an element into that array.

The default implementation performs a memset which would be unnecessary except that the garbage collector might trace the uninitialized array.

Was previously insertSlicing @since 0.6.0

Slices of immutable arrays: packages an offset and length with a backing array.

Since: 0.6.0

Slices of mutable arrays: packages an offset and length with a mutable backing array.

Since: 0.6.0

Create a Slice of an array.

O(1).

Since: 0.6.0

Create a MutableSlice of a mutable array.

O(1).

Since: 0.6.0

Create a Slice that covers the entire array.

Since: 0.6.0

Create a MutableSlice that covers the entire array.

Since: 0.6.0

Create a copy of an array except the element at the index is replaced with the given value.

Variant of modifyAt that forces the result before installing it in the array.

Variant of modifyAtF that forces the result before installing it in the array. Note that this requires Monad rather than Functor.

Delete the element at the given position.

Reverse the elements of an array.

Reverse the elements of a mutable array, in-place.

Reverse the elements of a slice of a mutable array, in-place.

Resize an array into one with the given size.

Resize an array without growing it.

Since: 0.6.0

Map over the elements of an array.

Note that because a new array must be created, the resulting array type can be different than the original.

Map strictly over the elements of an array.

Note that because a new array must be created, the resulting array type can be different than the original.

Map over a mutable array, modifying the elements in place.

Strictly map over a mutable array, modifying the elements in place.

Map over the elements of an array with the index.

Map strictly over the elements of an array with the index.

Note that because a new array must be created, the resulting array type can be different than the original.

Map over a mutable array with indices, modifying the elements in place.

Strictly map over a mutable array with indices, modifying the elements in place.

Modify the elements of a mutable array in-place.

Strictly modify the elements of a mutable array in-place.

The mapMaybe function is a version of map which can throw out elements. In particular, the functional arguments returns something of type Maybe b. If this is Nothing, no element is added on to the result array. If it is Just b, then b is included in the result array.

zip takes two arrays and returns an array of corresponding pairs.

zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]

If one input array is shorter than the other, excess elements of the longer array are discarded:

zip [1] ['a', 'b'] = [(1, 'a')]
zip [1, 2] ['a'] = [(1, 'a')]

zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two arrays to produce an array of the corresponding sums.

Variant of zipWith that provides the index of each pair of elements.

Swap the elements of the mutable array at the given indices.

Drop elements that do not satisfy the predicate.

Drop elements that do not satisfy the predicate which is applied to values and their indices.

The catMaybes function takes a list of Maybes and returns a list of all the Just values.

Extracts from an array of Either all the Left elements. All the Left elements are extracted in order.

Extracts from an array of Either all the Right elements. All the Right elements are extracted in order.

Partitions an array of Either into two arrays. All the Left elements are extracted, in order, to the first component of the output. Similarly the Right elements are extracted to the second component of the output.

find takes a predicate and an array, and returns the leftmost element of the array matching the prediate, or Nothing if there is no such element.

findIndex takes a predicate and an array, and returns the index of the leftmost element of the array matching the prediate, or Nothing if there is no such element.

Does the element occur in the structure?

The largest element of a structure.

The least element of a structure.

The largest element of a structure with respect to the given comparison function.

The least element of a structure with respect to the given comparison function.

Test the two arrays for equality.

Test the two mutable arrays for pointer equality. Does not check equality of elements.

This function does not behave deterministically. Optimization level and inlining can affect its results. However, the one thing that can be counted on is that if it returns True, the two immutable arrays are definitely the same. This is useful as shortcut for equality tests. However, keep in mind that a result of False tells us nothing about the arguments.

Left fold over the elements of an array.

Strict left fold over the elements of an array.

Right fold over the element of an array.

Strict right fold over the elements of an array.

Monoidal fold over the element of an array.

Strict monoidal fold over the elements of an array.

Strict left monoidal fold over the elements of an array.

Strict left fold over the elements of an array, where the accumulating function cares about the index of the element.

Right fold over the element of an array, lazy in the accumulator, provides index to the step function.

Strict right fold over the elements of an array, where the accumulating function cares about the index of the element.

Strict monoidal fold over the elements of an array.

Strict monoidal fold over the elements of an array.

Strict left monadic fold over the elements of an array.

Strict left monadic fold over the elements of an array.

The sum of a collection of actions, generalizing concat.

>>> asum (C.fromList ['Just' "Hello", 'Nothing', Just "World"] :: Array String)
Just "Hello"

Variant of zipWith that accepts an accumulator, performing a lazy right fold over both arrays.

Variant of foldrZipWith that provides the index of each pair of elements.

Variant of zipWith that accepts an accumulator, performing a strict left monadic fold over both arrays.

Variant of 'foldlZipWithM'' that provides the index of each pair of elements.

Map each element of the array to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results, see traverse_.

Map each element of the array to an action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results, see traverse.

Map each element of the array and its index to an action, evaluating these actions from left to right.

Map each element of the array and its index to an action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results, see itraverse.

Map each element of the array to an action, evaluate these actions from left to right, and collect the results in a new array.

Map each element of the array to an action, evaluate these actions from left to right, and collect the results in a new array.

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results. for a version that ignores the results see mapM_.

forM is mapM with its arguments flipped. For a version that ignores its results, see forM_.

Map each element of a structure to a monadic action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see mapM.

mapM_ = traverse_

forM_ is mapM_ with its arguments flipped. For a version that doesn't ignore its results, see forM.

for is traverse with its arguments flipped. For a version that ignores the results see for_.

for_ is traverse_ with its arguments flipped. For a version that doesn't ignore the results see for.

>>> for_ (C.fromList [1..4] :: PrimArray Int) print
1
2
3
4

Evaluate each action in the structure from left to right and collect the results. For a version that ignores the results see sequence_.

Evaluate each action in the structure from left to right and ignore the results. For a version that doesn't ignore the results see sequence.

Replace all locations in the input with the same value.

Equivalent to Data.Functor.<$.

Sequential application.

Equivalent to Control.Applicative.<*>.

scanl is similar to foldl, but returns an array of successive reduced values from the left:

scanl f z [x1, x2, ...] = [z, f z x1, f (f z x1) x2, ...]

Note that

last (toList (scanl f z xs)) == foldl f z xs.

A strictly accumulating version of scanl.

A variant of scanl whose function argument takes the current index as an argument.

A strictly accumulating version of iscanl.

A prescan.

prescanl f z = init . scanl f z

Example: prescanl (+) 0 <1,2,3,4> = <0,1,3,6>

Like prescanl, but with a strict accumulator.

A variant of prescanl where the function argument takes the current index of the array as an additional argument.

Like iprescanl, but with a strict accumulator.

Monadic accumulating strict left fold over the elements on an array.

Convert a list into an array.

Given an Int that is representative of the length of the list, convert the list into a mutable array of the given length.

Note: calls error if the given length is incorrect.

Convert a list into a mutable array of the given length.

Given an Int that is representative of the length of the list, convert the list into a mutable array of the given length.

Note: calls error if the given length is incorrect.

Create an array from a list. If the given length does not match the actual length, this function has undefined behavior.

Create an array from a list, reversing the order of the elements. If the given length does not match the actual length, this function has undefined behavior.

Create a mutable array from a list, reversing the order of the elements. If the given length does not match the actual length, this function has undefined behavior.

Convert an array to a list.

Convert a mutable array to a list.

Convert one type of array into another.

Lift an array (i.e. point to the data through an intervening thunk).

Since: 0.6.0

Lift a mutable array (i.e. point to the data through an intervening thunk).

Since: 0.6.0

Unlift an array (i.e. point to the data without an intervening thunk).

Since: 0.6.0

Unlift a mutable array (i.e. point to the data without an intervening thunk).

Since: 0.6.0

Clone a slice of an array.

Clone a slice of a mutable array.

Copy a slice of an array into a mutable array.

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

Turn a mutable array slice an immutable array by copying.

Since: 0.6.0

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

Turn a mutable array into an immutable one without copying. The mutable array should not be used after this conversion.

Lift an accumulating hash function over the elements of the array, returning the final accumulated hash.

Reduce the array and all of its elements to WHNF.

The Contiguous typeclass as an interface to a multitude of contiguous structures.

Some functions do not make sense on slices; for those, see ContiguousU.

The ContiguousU typeclass is an extension of the Contiguous typeclass, but includes operations that make sense only on uncliced contiguous structures.

Since: 0.6.0

A typeclass that is satisfied by all types. This is used used to provide a fake constraint for Array and SmallArray.

Boxed arrays.