Z.Data.Vector.Base

This module provides unified vector interface. Conceptually a vector is simply a slice of an array, for example this is the definition of boxed vector:

data Vector a = Vector !(SmallArray a)   !Int    !Int
                     -- payload           offset  length

The Vec class unified different type of vectors, and this module provide operation over Vec instances, with all the internal structures. Be careful on modifying internal slices, otherwise segmentation fault await.

The Vec typeclass

class Arr (IArray v) a => Vec v a where

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.

Associated Types

type IArray v :: Type -> Type

Vector's immutable array type

Methods

toArr :: v a -> (IArray v a, Int, Int)

Get underline array and slice range(offset and length).

fromArr :: IArray v a -> Int -> Int -> v a

Create a vector by slicing an array(with offset and length).

Instances

Prim a => Vec PrimArray a

Defined in Z.Data.Vector.Base

Associated Types

type IArray PrimArray :: Type -> Type

Methods

toArr :: PrimArray a -> (IArray PrimArray a, Int, Int)

fromArr :: IArray PrimArray a -> Int -> Int -> PrimArray a

Vec SmallArray a

Defined in Z.Data.Vector.Base

Associated Types

type IArray SmallArray :: Type -> Type

Methods

toArr :: SmallArray a -> (IArray SmallArray a, Int, Int)

fromArr :: IArray SmallArray a -> Int -> Int -> SmallArray a

Vec Array a

Defined in Z.Data.Vector.Base

Associated Types

type IArray Array :: Type -> Type

Methods

toArr :: Array a -> (IArray Array a, Int, Int)

fromArr :: IArray Array a -> Int -> Int -> Array a

Prim a => Vec PrimVector a

Defined in Z.Data.Vector.Base

Associated Types

type IArray PrimVector :: Type -> Type

Methods

toArr :: PrimVector a -> (IArray PrimVector a, Int, Int)

fromArr :: IArray PrimVector a -> Int -> Int -> PrimVector a

Vec Vector a

Defined in Z.Data.Vector.Base

Associated Types

type IArray Vector :: Type -> Type

Methods

toArr :: Vector a -> (IArray Vector a, Int, Int)

fromArr :: IArray Vector a -> Int -> Int -> Vector a

PrimUnlifted a => Vec (UnliftedArray :: Type -> Type) a

Defined in Z.Data.Vector.Base

Associated Types

type IArray UnliftedArray :: Type -> Type

Methods

toArr :: UnliftedArray a -> (IArray UnliftedArray a, Int, Int)

fromArr :: IArray UnliftedArray a -> Int -> Int -> UnliftedArray a

pattern Vec :: Vec v a => IArray v a -> Int -> Int -> v a

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!

arrVec :: (Vec v a, Vec u a, IArray v ~ IArray u) => v a -> u a

Change vector types based on same array type, e.g. construct an array from a slice, or vice-versa.

indexMaybe :: Vec v a => v a -> Int -> Maybe a

O(1) Index vector's element.

Return Nothing if index is out of bounds.

Boxed and unboxed vector type

data Vector a

Boxed vector

Constructors

Vector

Fields

• !(SmallArray a)

  payload

• !Int

  offset

• !Int

  length

Instances

Functor Vector

Defined in Z.Data.Vector.Base

Methods

fmap :: (a -> b) -> Vector a -> Vector b

(<$) :: a -> Vector b -> Vector a

Foldable Vector

Defined in Z.Data.Vector.Base

Methods

fold :: Monoid m => Vector m -> m

foldMap :: Monoid m => (a -> m) -> Vector a -> m

foldMap' :: Monoid m => (a -> m) -> Vector a -> m

foldr :: (a -> b -> b) -> b -> Vector a -> b

foldr' :: (a -> b -> b) -> b -> Vector a -> b

foldl :: (b -> a -> b) -> b -> Vector a -> b

foldl' :: (b -> a -> b) -> b -> Vector a -> b

foldr1 :: (a -> a -> a) -> Vector a -> a

foldl1 :: (a -> a -> a) -> Vector a -> a

toList :: Vector a -> [a]

null :: Vector a -> Bool

length :: Vector a -> Int

elem :: Eq a => a -> Vector a -> Bool

maximum :: Ord a => Vector a -> a

minimum :: Ord a => Vector a -> a

sum :: Num a => Vector a -> a

product :: Num a => Vector a -> a

Traversable Vector

Defined in Z.Data.Vector.Base

Methods

traverse :: Applicative f => (a -> f b) -> Vector a -> f (Vector b)

sequenceA :: Applicative f => Vector (f a) -> f (Vector a)

mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b)

sequence :: Monad m => Vector (m a) -> m (Vector a)

Hashable1 Vector

Defined in Z.Data.Vector.Base

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Vector a -> Int

Vec Vector a

Defined in Z.Data.Vector.Base

Associated Types

type IArray Vector :: Type -> Type

Methods

toArr :: Vector a -> (IArray Vector a, Int, Int)

fromArr :: IArray Vector a -> Int -> Int -> Vector a

IsList (Vector a)

Defined in Z.Data.Vector.Base

Associated Types

type Item (Vector a)

Methods

fromList :: [Item (Vector a)] -> Vector a

fromListN :: Int -> [Item (Vector a)] -> Vector a

toList :: Vector a -> [Item (Vector a)]

Eq a => Eq (Vector a)

Defined in Z.Data.Vector.Base

Methods

(==) :: Vector a -> Vector a -> Bool

(/=) :: Vector a -> Vector a -> Bool

Ord a => Ord (Vector a)

Defined in Z.Data.Vector.Base

Methods

compare :: Vector a -> Vector a -> Ordering

(<) :: Vector a -> Vector a -> Bool

(<=) :: Vector a -> Vector a -> Bool

(>) :: Vector a -> Vector a -> Bool

(>=) :: Vector a -> Vector a -> Bool

max :: Vector a -> Vector a -> Vector a

min :: Vector a -> Vector a -> Vector a

Read a => Read (Vector a)

Defined in Z.Data.Vector.Base

Methods

readsPrec :: Int -> ReadS (Vector a)

readList :: ReadS [Vector a]

readPrec :: ReadPrec (Vector a)

readListPrec :: ReadPrec [Vector a]

Show a => Show (Vector a)

Defined in Z.Data.Vector.Base

Methods

showsPrec :: Int -> Vector a -> ShowS

show :: Vector a -> String

showList :: [Vector a] -> ShowS

Semigroup (Vector a)

Defined in Z.Data.Vector.Base

Methods

(<>) :: Vector a -> Vector a -> Vector a

sconcat :: NonEmpty (Vector a) -> Vector a

stimes :: Integral b => b -> Vector a -> Vector a

Monoid (Vector a)

Defined in Z.Data.Vector.Base

Methods

mempty :: Vector a

mappend :: Vector a -> Vector a -> Vector a

mconcat :: [Vector a] -> Vector a

Arbitrary a => Arbitrary (Vector a)

Defined in Z.Data.Vector.Base

Methods

arbitrary :: Gen (Vector a)

shrink :: Vector a -> [Vector a]

CoArbitrary a => CoArbitrary (Vector a)

Defined in Z.Data.Vector.Base

Methods

coarbitrary :: Vector a -> Gen b -> Gen b

NFData a => NFData (Vector a)

Defined in Z.Data.Vector.Base

Methods

rnf :: Vector a -> ()

Hashable a => Hashable (Vector a)

Defined in Z.Data.Vector.Base

Methods

hashWithSalt :: Int -> Vector a -> Int

hash :: Vector a -> Int

Print a => Print (Vector a)

Defined in Z.Data.Text.Print

Methods

toUTF8BuilderP :: Int -> Vector a -> Builder ()

JSON a => JSON (Vector a)

Defined in Z.Data.JSON.Base

Methods

fromValue :: Value -> Converter (Vector a)

toValue :: Vector a -> Value

encodeJSON :: Vector a -> Builder ()

type IArray Vector

Defined in Z.Data.Vector.Base

type IArray Vector = SmallArray

type Item (Vector a)

Defined in Z.Data.Vector.Base

type Item (Vector a) = a

data PrimVector a

Primitive vector

Constructors

PrimVector

Fields

• !(PrimArray a)

  payload

• !Int

  offset in elements of type a rather than in bytes

• !Int

  length in elements of type a rather than in bytes

Instances

Ord Bytes

This is an INCOHERENT instance, compare binary data using SIMD.

Defined in Z.Data.Vector.Base

Methods

compare :: Bytes -> Bytes -> Ordering

(<) :: Bytes -> Bytes -> Bool

(<=) :: Bytes -> Bytes -> Bool

(>) :: Bytes -> Bytes -> Bool

(>=) :: Bytes -> Bytes -> Bool

max :: Bytes -> Bytes -> Bytes

min :: Bytes -> Bytes -> Bytes

FoldCase Bytes

This instance assume ASCII encoded bytes

Defined in Z.Data.Vector.Base

Methods

foldCase :: Bytes -> Bytes

foldCaseList :: [Bytes] -> [Bytes]

Hashable Bytes

This is an INCOHERENT instance, hash binary data using FNV-1a

Note this is different from Vector Word8 or [Word8] which use FNV-1.

Defined in Z.Data.Vector.Base

Methods

hashWithSalt :: Int -> Bytes -> Int

hash :: Bytes -> Int

JSON Bytes

This is an INCOHERENT instance, encode binary data with base64 encoding.

Defined in Z.Data.JSON.Base

Methods

fromValue :: Value -> Converter Bytes

toValue :: Bytes -> Value

encodeJSON :: Bytes -> Builder ()

Prim a => Vec PrimVector a

Defined in Z.Data.Vector.Base

Associated Types

type IArray PrimVector :: Type -> Type

Methods

toArr :: PrimVector a -> (IArray PrimVector a, Int, Int)

fromArr :: IArray PrimVector a -> Int -> Int -> PrimVector a

Prim a => IsList (PrimVector a)

Defined in Z.Data.Vector.Base

Associated Types

type Item (PrimVector a)

Methods

fromList :: [Item (PrimVector a)] -> PrimVector a

fromListN :: Int -> [Item (PrimVector a)] -> PrimVector a

toList :: PrimVector a -> [Item (PrimVector a)]

(Prim a, Eq a) => Eq (PrimVector a)

Defined in Z.Data.Vector.Base

Methods

(==) :: PrimVector a -> PrimVector a -> Bool

(/=) :: PrimVector a -> PrimVector a -> Bool

(Prim a, Ord a) => Ord (PrimVector a)

Defined in Z.Data.Vector.Base

Methods

compare :: PrimVector a -> PrimVector a -> Ordering

(<) :: PrimVector a -> PrimVector a -> Bool

(<=) :: PrimVector a -> PrimVector a -> Bool

(>) :: PrimVector a -> PrimVector a -> Bool

(>=) :: PrimVector a -> PrimVector a -> Bool

max :: PrimVector a -> PrimVector a -> PrimVector a

min :: PrimVector a -> PrimVector a -> PrimVector a

(Prim a, Read a) => Read (PrimVector a)

Defined in Z.Data.Vector.Base

Methods

readsPrec :: Int -> ReadS (PrimVector a)

readList :: ReadS [PrimVector a]

readPrec :: ReadPrec (PrimVector a)

readListPrec :: ReadPrec [PrimVector a]

(Prim a, Show a) => Show (PrimVector a)

Defined in Z.Data.Vector.Base

Methods

showsPrec :: Int -> PrimVector a -> ShowS

show :: PrimVector a -> String

showList :: [PrimVector a] -> ShowS

a ~ Word8 => IsString (PrimVector a)

This instance use packASCII, which may silently chop bytes, use it with ASCII literals only.

Defined in Z.Data.Vector.Base

Methods

fromString :: String -> PrimVector a

Prim a => Semigroup (PrimVector a)

Defined in Z.Data.Vector.Base

Methods

(<>) :: PrimVector a -> PrimVector a -> PrimVector a

sconcat :: NonEmpty (PrimVector a) -> PrimVector a

stimes :: Integral b => b -> PrimVector a -> PrimVector a

Prim a => Monoid (PrimVector a)

Defined in Z.Data.Vector.Base

Methods

mempty :: PrimVector a

mappend :: PrimVector a -> PrimVector a -> PrimVector a

mconcat :: [PrimVector a] -> PrimVector a

(Prim a, Arbitrary a) => Arbitrary (PrimVector a)

Defined in Z.Data.Vector.Base

Methods

arbitrary :: Gen (PrimVector a)

shrink :: PrimVector a -> [PrimVector a]

(Prim a, CoArbitrary a) => CoArbitrary (PrimVector a)

Defined in Z.Data.Vector.Base

Methods

coarbitrary :: PrimVector a -> Gen b -> Gen b

NFData (PrimVector a)

Defined in Z.Data.Vector.Base

Methods

rnf :: PrimVector a -> ()

(Hashable a, Prim a) => Hashable (PrimVector a)

Defined in Z.Data.Vector.Base

Methods

hashWithSalt :: Int -> PrimVector a -> Int

hash :: PrimVector a -> Int

(Prim a, Print a) => Print (PrimVector a)

Defined in Z.Data.Text.Print

Methods

toUTF8BuilderP :: Int -> PrimVector a -> Builder ()

(Prim a, JSON a) => JSON (PrimVector a)

Defined in Z.Data.JSON.Base

Methods

fromValue :: Value -> Converter (PrimVector a)

toValue :: PrimVector a -> Value

encodeJSON :: PrimVector a -> Builder ()

type IArray PrimVector

Defined in Z.Data.Vector.Base

type IArray PrimVector = PrimArray

type Item (PrimVector a)

Defined in Z.Data.Vector.Base

type Item (PrimVector a) = a

Word8 vector

type Bytes = PrimVector Word8

Bytes is just primitive word8 vectors.

packASCII :: String -> Bytes

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

Creating utilities

create

Arguments

:: Vec v a

=> Int

length in elements of type a

-> (forall s. MArr (IArray v) s a -> ST s ())

initialization function

-> v a

Create a vector with size N.

create'

Arguments

:: Vec v a

=> Int

length in elements of type a

-> (forall s. MArr (IArray v) s a -> ST s (IPair (MArr (IArray v) s a)))

initialization function return a result size and array, the result must start from index 0

-> v a

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

creating

Arguments

:: Vec v a

=> Int

-> (forall s. MArr (IArray v) s a -> ST s b)

initialization function

-> (b, v a)

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.

creating'

Arguments

:: Vec v a

=> Int

-> (forall s. MArr (IArray v) s a -> ST s (b, IPair (MArr (IArray v) s a)))

initialization function

-> (b, v a)

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.

createN

Arguments

:: (Vec v a, HasCallStack)

=> Int

length's upper bound

-> (forall s. MArr (IArray v) s a -> ST s Int)

initialization function which return the actual length

-> v a

Create a vector up to a specific length.

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

createN2 :: (Vec v a, Vec u b, HasCallStack) => Int -> Int -> (forall s. MArr (IArray v) s a -> MArr (IArray u) s b -> ST s (Int, Int)) -> (v a, u b)

Create two vector up to a specific length.

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

empty :: Vec v a => v a

O(1). The empty vector.

singleton :: Vec v a => a -> v a

O(1). Single element vector.

copy :: Vec v a => v a -> v a

O(n). Copy a vector from slice.

Conversion between list

pack :: Vec v a => [a] -> v a

O(n) Convert a list into a vector

Alias for packN defaultInitSize.

packN :: forall v a. Vec v a => Int -> [a] -> v a

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.

packN' :: forall v a. Vec v a => Int -> [a] -> v a

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.

packR :: Vec v a => [a] -> v a

O(n) Alias for packRN defaultInitSize.

packRN :: forall v a. Vec v a => Int -> [a] -> v a

O(n) packN in reverse order.

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

packRN' :: forall v a. Vec v a => Int -> [a] -> v a

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.

unpack :: Vec v a => v a -> [a]

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.

unpackR :: Vec v a => v a -> [a]

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

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

Basic interface

null :: Vec v a => v a -> Bool

O(1) Test whether a vector is empty.

length :: Vec v a => v a -> Int

O(1) The length of a vector.

append :: Vec v a => v a -> v a -> v a

O(m+n)

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

map :: forall u v a b. (Vec u a, Vec v b) => (a -> b) -> u a -> v b

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.

map' :: forall u v a b. (Vec u a, Vec v b) => (a -> b) -> u a -> v b

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 ).

imap' :: forall u v a b. (Vec u a, Vec v b) => (Int -> a -> b) -> u a -> v b

Strict mapping with index.

traverse :: (Vec v a, Vec u b, Applicative f) => (a -> f b) -> v a -> f (u b)

Traverse vector and gather result in another vector.

There're rules to optimize the intermedia list away when f is an instance of PrimMoand, such as IO, ST or Parser.

traverseWithIndex :: (Vec v a, Vec u b, Applicative f) => (Int -> a -> f b) -> v a -> f (u b)

Traverse vector and gather result in another vector.

traverse_ :: (Vec v a, Applicative f) => (a -> f b) -> v a -> f ()

Traverse vector without gathering result.

traverseWithIndex_ :: (Vec v a, Applicative f) => (Int -> a -> f b) -> v a -> f ()

Traverse vector with index.

foldl' :: Vec v a => (b -> a -> b) -> b -> v a -> b

Strict left to right fold.

ifoldl' :: Vec v a => (b -> Int -> a -> b) -> b -> v a -> b

Strict left to right fold with index.

foldl1' :: forall v a. (Vec v a, HasCallStack) => (a -> a -> a) -> v a -> a

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

Throw EmptyVector if vector is empty.

foldl1Maybe' :: forall v a. Vec v a => (a -> a -> a) -> v a -> Maybe a

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

foldr' :: Vec v a => (a -> b -> b) -> b -> v a -> b

Strict right to left fold

ifoldr' :: Vec v a => (Int -> a -> b -> b) -> b -> v a -> b

Strict right to left fold with index

NOTE: the index is counting from 0, not backwards

foldr1' :: forall v a. (Vec v a, HasCallStack) => (a -> a -> a) -> v a -> a

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

Throw EmptyVector if vector is empty.

foldr1Maybe' :: forall v a. Vec v a => (a -> a -> a) -> v a -> Maybe a

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

Special folds

concat :: forall v a. Vec v a => [v a] -> v a

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.

concatMap :: Vec v a => (a -> v a) -> v a -> v a

Map a function over a vector and concatenate the results

maximum :: (Vec v a, Ord a, HasCallStack) => v a -> a

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.

minimum :: (Vec v a, Ord a, HasCallStack) => v a -> a

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

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

maximumMaybe :: (Vec v a, Ord a) => v a -> Maybe a

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

minimumMaybe :: (Vec v a, Ord a) => v a -> Maybe a

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

sum :: (Vec v a, Num a) => v a -> a

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

count :: (Vec v a, Eq a) => a -> v a -> Int

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

countBytes :: Word8 -> Bytes -> Int

product :: (Vec v a, Num a) => v a -> a

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

product' :: (Vec v a, Num a, Eq a) => v a -> a

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].

all :: Vec v a => (a -> Bool) -> v a -> Bool

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

any :: Vec v a => (a -> Bool) -> v a -> Bool

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

Building vector

Accumulating maps

mapAccumL :: forall u v a b c. (Vec u b, Vec v c) => (a -> b -> (a, c)) -> a -> u b -> (a, v c)

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.

mapAccumR :: forall u v a b c. (Vec u b, Vec v c) => (a -> b -> (a, c)) -> a -> u b -> (a, v c)

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.

Generating and unfolding vector

replicate :: Vec v a => Int -> a -> v a

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.

replicateM :: (Applicative f, Vec v a) => Int -> f a -> f (v a)

A version of replicateM which works on Vec, with specialized rules under PrimMonad.

There're rules to optimize the intermedia list away when m is an instance of PrimMoand, such as IO, ST or Parser.

cycleN :: forall v a. Vec v a => Int -> v a -> v a

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

unfoldr :: Vec u b => (a -> Maybe (b, a)) -> a -> u b

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]

unfoldrN :: forall v a b. Vec v b => Int -> (a -> Maybe (b, a)) -> a -> (v b, Maybe a)

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)

Searching by equality

elem :: (Vec v a, Eq a) => a -> v a -> Bool

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

notElem :: (Vec v a, Eq a) => a -> v a -> Bool

O(n) 'not . elem'

elemIndex :: (Vec v a, Eq a) => a -> v a -> Maybe Int

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.

Misc

data IPair a

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

Constructors

IPair

Fields

• ifst :: !Int
• isnd :: a

Instances

Functor IPair

Defined in Z.Data.Vector.Base

Methods

fmap :: (a -> b) -> IPair a -> IPair b

(<$) :: a -> IPair b -> IPair a

Eq a => Eq (IPair a)

Defined in Z.Data.Vector.Base

Methods

(==) :: IPair a -> IPair a -> Bool

(/=) :: IPair a -> IPair a -> Bool

Ord a => Ord (IPair a)

Defined in Z.Data.Vector.Base

Methods

compare :: IPair a -> IPair a -> Ordering

(<) :: IPair a -> IPair a -> Bool

(<=) :: IPair a -> IPair a -> Bool

(>) :: IPair a -> IPair a -> Bool

(>=) :: IPair a -> IPair a -> Bool

max :: IPair a -> IPair a -> IPair a

min :: IPair a -> IPair a -> IPair a

Show a => Show (IPair a)

Defined in Z.Data.Vector.Base

Methods

showsPrec :: Int -> IPair a -> ShowS

show :: IPair a -> String

showList :: [IPair a] -> ShowS

Arbitrary v => Arbitrary (IPair v)

Defined in Z.Data.Vector.Base

Methods

arbitrary :: Gen (IPair v)

shrink :: IPair v -> [IPair v]

CoArbitrary v => CoArbitrary (IPair v)

Defined in Z.Data.Vector.Base

Methods

coarbitrary :: IPair v -> Gen b -> Gen b

NFData a => NFData (IPair a)

Defined in Z.Data.Vector.Base

Methods

rnf :: IPair a -> ()

mapIPair' :: (a -> b) -> IPair a -> IPair b

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

fromIPair :: IPair a -> (Int, a)

toIPair :: (Int, a) -> IPair a

defaultInitSize :: Int

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

chunkOverhead :: Int

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

defaultChunkSize :: Int

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

smallChunkSize :: Int

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

data VectorException

All exception can be throw by using Vec.

Constructors

IndexOutOfVectorRange !Int CallStack

EmptyVector CallStack

Instances

Show VectorException

Defined in Z.Data.Vector.Base

Methods

showsPrec :: Int -> VectorException -> ShowS

show :: VectorException -> String

showList :: [VectorException] -> ShowS

Exception VectorException

Defined in Z.Data.Vector.Base

Methods

toException :: VectorException -> SomeException

fromException :: SomeException -> Maybe VectorException

displayException :: VectorException -> String

errorEmptyVector :: HasCallStack => a

errorOutRange :: HasCallStack => Int -> a

castVector :: (Vec v a, Cast a b) => v a -> v b

Cast between vectors

replicatePM :: (PrimMonad m, Vec v a) => Int -> m a -> m (v a)

A version of replicateM which works on PrimMonad and Vec.

traverseWithIndexPM :: forall m v u a b. (PrimMonad m, Vec v a, Vec u b) => (Int -> a -> m b) -> v a -> m (u b)

C FFI

c_strcmp :: Addr# -> Addr# -> IO CInt

c_memchr :: ByteArray# -> Int -> Word8 -> Int -> Int

c_memrchr :: ByteArray# -> Int -> Word8 -> Int -> Int

c_strlen :: Addr# -> IO CSize

c_ascii_validate_addr :: Addr# -> Int -> IO Int

c_fnv_hash_addr :: Addr# -> Int -> Int -> IO Int

c_fnv_hash_ba :: ByteArray# -> Int -> Int -> Int -> IO Int