Typeclass for box and unboxed vectors, which are created by slicing arrays.

Instead of providing a generalized vector with polymorphric array field, we use this typeclass so that instances use concrete array type can unpack their array payload.

Vector types, e.g. Vector,PrimVector... are obivious instances, with O(1) toArr and fromArr, which convert slices to (array, offset, length) tuple back and forth.

Array types can also be instances of this class, e.g. Array, PrimArray..., in this case toArr will always return offset 0 and whole array length, and fromArr is O(n) copyArr.

A pattern synonyms for matching the underline array, offset and length.

This is a bidirectional pattern synonyms, but very unsafe if not use properly. Make sure your slice is within array's bounds!

Construct a Vec by slicing a whole array.

O(1) Index array element.

Return Nothing if index is out of bounds.

Boxed vector

Primitive vector

Bytes is just primitive word8 vectors.

O(n), pack an ASCII String, multi-bytes char WILL BE CHOPPED!

Create a vector with size N.

Create a vector with a initial size N array (which may not be the final array).

Create a vector with a initial size N array, return both the vector and the monadic result during creating.

The result is not demanded strictly while the returned vector will be in normal form. It this is not desired, use return $! idiom in your initialization function.

Create a vector with a initial size N array (which may not be the final array), return both the vector and the monadic result during creating.

The result is not demanded strictly while the returned vector will be in normal form. It this is not desired, use return $! idiom in your initialization function.

Create a vector up to a specific length.

If the initialization function return a length larger than initial size, an IndexOutOfVectorRange will be raised.

Create two vector up to a specific length.

If the initialization function return lengths larger than initial sizes, an IndexOutOfVectorRange will be raised.

O(1). The empty vector.

O(1). Single element vector.

O(n). Copy a vector from slice.

O(n) Convert a list into a vector

Alias for packN defaultInitSize.

O(n) Convert a list into a vector with an approximate size.

If the list's length is large than the size given, we simply double the buffer size and continue building.

This function is a good consumer in the sense of build/foldr fusion.

O(n) Convert a list into a vector with given size.

If the list's length is large than the size given, we drop the rest elements.

This function is a good consumer in the sense of build/foldr fusion.

O(n) Alias for packRN defaultInitSize.

O(n) packN in reverse order.

This function is a good consumer in the sense of build/foldr fusion.

O(n) packN' in reverse order.

>>> packRN' 3 [1,2,3,4,5]
>>> [3,2,1]

This function is a good consumer in the sense of build/foldr fusion.

O(n) Convert vector to a list.

Unpacking is done lazily. i.e. we will retain reference to the array until all element are consumed.

This function is a good producer in the sense of build/foldr fusion.

O(n) Convert vector to a list in reverse order.

This function is a good producer in the sense of build/foldr fusion.

O(1) Test whether a vector is empty.

O(1) The length of a vector.

O(m+n)

There's no need to guard empty vector because we guard them for you, so appending empty vectors are no-ops.

Mapping between vectors (possiblely with two different vector types).

NOTE, the result vector contain thunks in lifted Vector case, use map' if that's not desired.

For PrimVector, map and map' are same, since PrimVectors never store thunks.

Mapping between vectors (possiblely with two different vector types).

This is the strict version map. Note that the Functor instance of lifted Vector is defined with map to statisfy laws, which this strict version breaks (map' id arrayContainsBottom /= arrayContainsBottom ).

Strict mapping with index.

Traverse vector and gather result in another vector,

Traverse vector and gather result in another vector,

Traverse vector without gathering result.

Traverse vector with index.

Strict left to right fold.

Strict left to right fold with index.

Strict left to right fold using first element as the initial value.

Throw EmptyVector if vector is empty.

Strict left to right fold using first element as the initial value. return Nothing when vector is empty.

Strict right to left fold

Strict right to left fold with index

NOTE: the index is counting from 0, not backwards

Strict right to left fold using last element as the initial value.

Throw EmptyVector if vector is empty.

Strict right to left fold using last element as the initial value, return Nothing when vector is empty.

O(n) Concatenate a list of vector.

Note: concat have to force the entire list to filter out empty vector and calculate the length for allocation.

Map a function over a vector and concatenate the results

O(n) maximum returns the maximum value from a vector

It's defined with foldl1', an EmptyVector exception will be thrown in the case of an empty vector.

O(n) minimum returns the minimum value from a vector

An EmptyVector exception will be thrown in the case of an empty vector.

O(n) maximum returns the maximum value from a vector, return Nothing in the case of an empty vector.

O(n) minimum returns the minimum value from a vector, return Nothing in the case of an empty vector.

O(n) sum returns the sum value from a vector

O(n) count returns count of an element from a vector

O(n) product returns the product value from a vector

O(n) product returns the product value from a vector

This function will shortcut on zero. Note this behavior change the semantics for lifted vector: product [1,0,undefined] /= product' [1,0,undefined].

O(n) Applied to a predicate and a vector, all determines if all elements of the vector satisfy the predicate.

O(n) Applied to a predicate and a vector, any determines if any elements of the vector satisfy the predicate.

The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a vector, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new list.

Note, this function will only force the result tuple, not the elements inside, to prevent creating thunks during mapAccumL, seq your accumulator and result with the result tuple.

The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a vector, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new vector.

The same strictness property with mapAccumL applys to mapAccumR too.

O(n) replicate n x is a vector of length n with x the value of every element.

Note: replicate will not force the element in boxed vector case.

O(n*m) cycleN a vector n times.

O(n), where n is the length of the result. The unfoldr function is analogous to the List 'unfoldr'. unfoldr builds a vector from a seed value. The function takes the element and returns Nothing if it is done producing the vector or returns Just (a,b), in which case, a is the next byte in the string, and b is the seed value for further production.

Examples:

   unfoldr (\x -> if x <= 5 then Just (x, x + 1) else Nothing) 0
== pack [0, 1, 2, 3, 4, 5]

O(n) Like unfoldr, unfoldrN builds a vector from a seed value. However, the length of the result is limited by the first argument to unfoldrN. This function is more efficient than unfoldr when the maximum length of the result is known.

The following equation relates unfoldrN and unfoldr:

fst (unfoldrN n f s) == take n (unfoldr f s)

O(n) elem test if given element is in given vector.

O(n) 'not . elem'

O(n) The elemIndex function returns the index of the first element in the given vector which is equal to the query element, or Nothing if there is no such element.

Pair type to help GHC unpack in some loops, useful when write fast folds.

Unlike Functor instance, this mapping evaluate value inside IPair strictly.

defaultInitSize = 30, used as initialize size when packing list of unknown size.

The memory management overhead. Currently this is tuned for GHC only.

The chunk size used for I/O. Currently set to 16k - chunkOverhead

The recommended chunk size. Currently set to 4k - chunkOverhead.

All exception can be throw by using Vec.

Cast between vectors