-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Text implementation based on unboxed char vector.
--
-- Text implementation based on unboxed char vector.
@package vector-text
@version 1.1.5
module Data.Container.Vector
-- | O(1)
alloc :: Vector v a => Int -> v a
-- | O(n)
replicate' :: Vector v a => Int -> v a -> v a
-- | O(1)
index :: Vector v a => v a -> Int -> Maybe a
-- | O(1)
(!) :: Vector v a => v a -> Int -> Maybe a
infixl 9 !
-- | O(1)
(!!) :: Vector v a => v a -> Int -> a
infixl 9 !!
-- | O(1)
head :: Vector v a => v a -> Maybe a
-- | O(1)
last :: Vector v a => v a -> Maybe a
-- | O(1)
init :: Vector v a => v a -> Maybe (v a)
-- | O(1)
tail :: Vector v a => v a -> Maybe (v a)
-- | O(1)
splitHead :: Vector v a => v a -> Maybe (a, v a)
-- | O(1)
splitLast :: Vector v a => v a -> Maybe (a, v a)
-- | O(1)
unsafeSplitHead :: Vector v a => v a -> (a, v a)
-- | O(1)
unsafeSplitLast :: Vector v a => v a -> (a, v a)
-- | O(s)
takeTill :: Vector v a => (a -> Bool) -> v a -> v a
-- | O(s)
takeWhile :: Vector v a => (a -> Bool) -> v a -> v a
-- | O(s) Just like takeWhile, but uses streaming instead of slicing.
takeWhileStream :: Vector v a => (a -> Bool) -> v a -> v a
-- | O(s)
dropWhileStream :: Vector v a => (a -> Bool) -> v a -> v a
-- | O(n)
breakAll :: Vector v a => (a -> Bool) -> v a -> [v a]
-- | O(n)
replaceUsing :: Vector v a => (a -> Bool) -> (a -> v a) -> v a -> v a
-- | O(n)
replace :: (Vector v a, Eq a) => a -> v a -> v a -> v a
commonPrefixes :: (Vector v a, Eq a) => v a -> v a -> Maybe (v a, v a, v a)
-- | O(n) Split the vector into the longest prefix of elements that
-- satisfy the predicate and the rest without copying.
span :: Vector v a => a -> Bool -> v a -> (v a, v a)
-- | Map a function over a vector and concatenate the results.
concatMap :: (Vector v a, Vector v b) => a -> v b -> v a -> v b
-- | O(n) Apply a function to every element of a vector and its
-- index
imap :: (Vector v a, Vector v b) => Int -> a -> b -> v a -> v b
-- | O(n) Map a function over a vector
map :: (Vector v a, Vector v b) => a -> b -> v a -> v b
-- | O(n) Concatenate all vectors in the list
concat :: Vector v a => [v a] -> v a
-- | O(n) Append an element
snoc :: Vector v a => v a -> a -> v a
-- | O(n) Prepend an element
cons :: Vector v a => a -> v a -> v a
-- | O(1) Vector with exactly one element
singleton :: Vector v a => a -> v a
-- | O(1) Yield all but the first n elements without
-- copying. The vector must contain at least n elements but this
-- is not checked.
unsafeDrop :: Vector v a => Int -> v a -> v a
-- | O(1) Yield the first n elements without copying. The
-- vector must contain at least n elements but this is not
-- checked.
unsafeTake :: Vector v a => Int -> v a -> v a
-- | O(1) Yield all but the first element without copying. The
-- vector may not be empty but this is not checked.
unsafeTail :: Vector v a => v a -> v a
-- | O(1) Yield all but the last element without copying. The vector
-- may not be empty but this is not checked.
unsafeInit :: Vector v a => v a -> v a
-- | O(1) Yield a slice of the vector without copying. The vector
-- must contain at least i+n elements but this is not checked.
unsafeSlice :: Vector v a => Int -> Int -> v a -> v a
-- | O(1) Yield the first n elements paired with the
-- remainder without copying.
--
-- Note that splitAt n v is equivalent to
-- (take n v, drop n v) but slightly more
-- efficient.
splitAt :: Vector v a => Int -> v a -> (v a, v a)
-- | O(1) Last element without checking if the vector is empty
unsafeLast :: Vector v a => v a -> a
-- | O(1) First element without checking if the vector is empty
unsafeHead :: Vector v a => v a -> a
-- | O(1) Unsafe indexing without bounds checking
unsafeIndex :: Vector v a => v a -> Int -> a
-- | O(1) Test whether a vector is empty
null :: Vector v a => v a -> Bool
-- | O(1) Yield the length of the vector
length :: Vector v a => v a -> Int
instance (Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector a, Data.Convert.Class.Convertible' GHC.Types.Char a) => Data.String.IsString (Data.Vector.Unboxed.Base.Vector a)
instance (Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector a, Data.Convert.Class.Convertible' GHC.Types.Char a) => Data.Convert.Class.Convertible GHC.Types.Char (Data.Vector.Unboxed.Base.Vector a)
instance (Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector a, Data.Convert.Class.Convertible' t a) => Data.Convert.Class.Convertible [t] (Data.Vector.Unboxed.Base.Vector a)
instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector a => Data.Convert.Class.Convertible [a] (Data.Vector.Unboxed.Base.Vector a)
instance (Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector a, Data.Convert.Class.Convertible' a t) => Data.Convert.Class.Convertible (Data.Vector.Unboxed.Base.Vector a) [t]
instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector a => Data.Convert.Class.Convertible (Data.Vector.Unboxed.Base.Vector a) [a]
instance (Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector a, Data.Convert.Class.Convertible' GHC.Types.Char a) => Data.Convert.Class.Convertible Data.Text.Internal.Text (Data.Vector.Unboxed.Base.Vector a)
instance (Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector a, Data.Convert.Class.Convertible' a GHC.Types.Char) => Data.Convert.Class.Convertible (Data.Vector.Unboxed.Base.Vector a) Data.Text.Internal.Text
module Data.Text32
type Text32 = Vector Char
class (Vector Vector a, MVector MVector a) => Unbox a
-- | O(1) Unzip 6 vectors
unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector (a, b, c, d, e, f) -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
-- | O(1) Zip 6 vectors
zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector (a, b, c, d, e, f)
-- | O(1) Unzip 5 vectors
unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector (a, b, c, d, e) -> (Vector a, Vector b, Vector c, Vector d, Vector e)
-- | O(1) Zip 5 vectors
zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)
-- | O(1) Unzip 4 vectors
unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)
-- | O(1) Zip 4 vectors
zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)
-- | O(1) Unzip 3 vectors
unzip3 :: (Unbox a, Unbox b, Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
-- | O(1) Zip 3 vectors
zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a -> Vector b -> Vector c -> Vector (a, b, c)
-- | O(1) Unzip 2 vectors
unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a, Vector b)
-- | O(1) Zip 2 vectors
zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)
-- | O(n) Copy an immutable vector into a mutable one. The two
-- vectors must have the same length.
copy :: (Unbox a, PrimMonad m) => MVector PrimState m a -> Vector a -> m ()
-- | O(n) Copy an immutable vector into a mutable one. The two
-- vectors must have the same length. This is not checked.
unsafeCopy :: (Unbox a, PrimMonad m) => MVector PrimState m a -> Vector a -> m ()
-- | O(n) Yield an immutable copy of the mutable vector.
freeze :: (Unbox a, PrimMonad m) => MVector PrimState m a -> m Vector a
-- | O(n) Yield a mutable copy of the immutable vector.
thaw :: (Unbox a, PrimMonad m) => Vector a -> m MVector PrimState m a
-- | O(1) Unsafely convert an immutable vector to a mutable one
-- without copying. The immutable vector may not be used after this
-- operation.
unsafeThaw :: (Unbox a, PrimMonad m) => Vector a -> m MVector PrimState m a
-- | O(1) Unsafe convert a mutable vector to an immutable one
-- without copying. The mutable vector may not be used after this
-- operation.
unsafeFreeze :: (Unbox a, PrimMonad m) => MVector PrimState m a -> m Vector a
-- | O(n) Convert the first n elements of a list to a
-- vector
--
--
-- fromListN n xs = fromList (take n xs)
--
fromListN :: Unbox a => Int -> [a] -> Vector a
-- | O(n) Convert a list to a vector
fromList :: Unbox a => [a] -> Vector a
-- | O(n) Convert a vector to a list
toList :: Unbox a => Vector a -> [a]
-- | O(n) Right-to-left scan over a non-empty vector with a strict
-- accumulator
scanr1' :: Unbox a => a -> a -> a -> Vector a -> Vector a
-- | O(n) Right-to-left scan over a non-empty vector
scanr1 :: Unbox a => a -> a -> a -> Vector a -> Vector a
-- | O(n) Right-to-left Haskell-style scan with strict accumulator
scanr' :: (Unbox a, Unbox b) => a -> b -> b -> b -> Vector a -> Vector b
-- | O(n) Right-to-left Haskell-style scan
scanr :: (Unbox a, Unbox b) => a -> b -> b -> b -> Vector a -> Vector b
-- | O(n) Right-to-left scan with strict accumulator
postscanr' :: (Unbox a, Unbox b) => a -> b -> b -> b -> Vector a -> Vector b
-- | O(n) Right-to-left scan
postscanr :: (Unbox a, Unbox b) => a -> b -> b -> b -> Vector a -> Vector b
-- | O(n) Right-to-left prescan with strict accumulator
prescanr' :: (Unbox a, Unbox b) => a -> b -> b -> b -> Vector a -> Vector b
-- | O(n) Right-to-left prescan
--
--
-- prescanr f z = reverse . prescanl (flip f) z . reverse
--
prescanr :: (Unbox a, Unbox b) => a -> b -> b -> b -> Vector a -> Vector b
-- | O(n) Scan over a non-empty vector with a strict accumulator
scanl1' :: Unbox a => a -> a -> a -> Vector a -> Vector a
-- | O(n) Scan over a non-empty vector
--
--
-- scanl f <x1,...,xn> = <y1,...,yn>
-- where y1 = x1
-- yi = f y(i-1) xi
--
scanl1 :: Unbox a => a -> a -> a -> Vector a -> Vector a
-- | O(n) Haskell-style scan with strict accumulator
scanl' :: (Unbox a, Unbox b) => a -> b -> a -> a -> Vector b -> Vector a
-- | O(n) Haskell-style scan
--
--
-- scanl f z <x1,...,xn> = <y1,...,y(n+1)>
-- where y1 = z
-- yi = f y(i-1) x(i-1)
--
--
-- Example: scanl (+) 0 <1,2,3,4> = <0,1,3,6,10>
scanl :: (Unbox a, Unbox b) => a -> b -> a -> a -> Vector b -> Vector a
-- | O(n) Scan with strict accumulator
postscanl' :: (Unbox a, Unbox b) => a -> b -> a -> a -> Vector b -> Vector a
-- | O(n) Scan
--
--
-- postscanl f z = tail . scanl f z
--
--
-- Example: postscanl (+) 0 <1,2,3,4> = <1,3,6,10>
postscanl :: (Unbox a, Unbox b) => a -> b -> a -> a -> Vector b -> Vector a
-- | O(n) Prescan with strict accumulator
prescanl' :: (Unbox a, Unbox b) => a -> b -> a -> a -> Vector b -> Vector a
-- | O(n) Prescan
--
--
-- prescanl f z = init . scanl f z
--
--
-- Example: prescanl (+) 0 <1,2,3,4> = <0,1,3,6>
prescanl :: (Unbox a, Unbox b) => a -> b -> a -> a -> Vector b -> Vector a
-- | O(n) Monadic fold over non-empty vectors with strict
-- accumulator that discards the result
fold1M'_ :: (Monad m, Unbox a) => a -> a -> m a -> Vector a -> m ()
-- | O(n) Monadic fold with strict accumulator that discards the
-- result (action applied to each element and its index)
ifoldM'_ :: (Monad m, Unbox b) => a -> Int -> b -> m a -> a -> Vector b -> m ()
-- | O(n) Monadic fold with strict accumulator that discards the
-- result
foldM'_ :: (Monad m, Unbox b) => a -> b -> m a -> a -> Vector b -> m ()
-- | O(n) Monadic fold over non-empty vectors that discards the
-- result
fold1M_ :: (Monad m, Unbox a) => a -> a -> m a -> Vector a -> m ()
-- | O(n) Monadic fold that discards the result (action applied to
-- each element and its index)
ifoldM_ :: (Monad m, Unbox b) => a -> Int -> b -> m a -> a -> Vector b -> m ()
-- | O(n) Monadic fold that discards the result
foldM_ :: (Monad m, Unbox b) => a -> b -> m a -> a -> Vector b -> m ()
-- | O(n) Monadic fold over non-empty vectors with strict
-- accumulator
fold1M' :: (Monad m, Unbox a) => a -> a -> m a -> Vector a -> m a
-- | O(n) Monadic fold with strict accumulator (action applied to
-- each element and its index)
ifoldM' :: (Monad m, Unbox b) => a -> Int -> b -> m a -> a -> Vector b -> m a
-- | O(n) Monadic fold with strict accumulator
foldM' :: (Monad m, Unbox b) => a -> b -> m a -> a -> Vector b -> m a
-- | O(n) Monadic fold over non-empty vectors
fold1M :: (Monad m, Unbox a) => a -> a -> m a -> Vector a -> m a
-- | O(n) Monadic fold (action applied to each element and its
-- index)
ifoldM :: (Monad m, Unbox b) => a -> Int -> b -> m a -> a -> Vector b -> m a
-- | O(n) Monadic fold
foldM :: (Monad m, Unbox b) => a -> b -> m a -> a -> Vector b -> m a
-- | O(n) Yield the index of the minimum element of the vector
-- according to the given comparison function. The vector may not be
-- empty.
minIndexBy :: Unbox a => a -> a -> Ordering -> Vector a -> Int
-- | O(n) Yield the index of the minimum element of the vector. The
-- vector may not be empty.
minIndex :: (Unbox a, Ord a) => Vector a -> Int
-- | O(n) Yield the index of the maximum element of the vector
-- according to the given comparison function. The vector may not be
-- empty.
maxIndexBy :: Unbox a => a -> a -> Ordering -> Vector a -> Int
-- | O(n) Yield the index of the maximum element of the vector. The
-- vector may not be empty.
maxIndex :: (Unbox a, Ord a) => Vector a -> Int
-- | O(n) Yield the minimum element of the vector according to the
-- given comparison function. The vector may not be empty.
minimumBy :: Unbox a => a -> a -> Ordering -> Vector a -> a
-- | O(n) Yield the minimum element of the vector. The vector may
-- not be empty.
minimum :: (Unbox a, Ord a) => Vector a -> a
-- | O(n) Yield the maximum element of the vector according to the
-- given comparison function. The vector may not be empty.
maximumBy :: Unbox a => a -> a -> Ordering -> Vector a -> a
-- | O(n) Yield the maximum element of the vector. The vector may
-- not be empty.
maximum :: (Unbox a, Ord a) => Vector a -> a
-- | O(n) Compute the produce of the elements
product :: (Unbox a, Num a) => Vector a -> a
-- | O(n) Compute the sum of the elements
sum :: (Unbox a, Num a) => Vector a -> a
-- | O(n) Check if any element is True
or :: Vector Bool -> Bool
-- | O(n) Check if all elements are True
and :: Vector Bool -> Bool
-- | O(n) Check if any element satisfies the predicate.
any :: Unbox a => a -> Bool -> Vector a -> Bool
-- | O(n) Check if all elements satisfy the predicate.
all :: Unbox a => a -> Bool -> Vector a -> Bool
-- | O(n) Right fold with strict accumulator (function applied to
-- each element and its index)
ifoldr' :: Unbox a => Int -> a -> b -> b -> b -> Vector a -> b
-- | O(n) Right fold (function applied to each element and its
-- index)
ifoldr :: Unbox a => Int -> a -> b -> b -> b -> Vector a -> b
-- | O(n) Left fold with strict accumulator (function applied to
-- each element and its index)
ifoldl' :: Unbox b => a -> Int -> b -> a -> a -> Vector b -> a
-- | O(n) Left fold (function applied to each element and its index)
ifoldl :: Unbox b => a -> Int -> b -> a -> a -> Vector b -> a
-- | O(n) Right fold on non-empty vectors with strict accumulator
foldr1' :: Unbox a => a -> a -> a -> Vector a -> a
-- | O(n) Right fold with a strict accumulator
foldr' :: Unbox a => a -> b -> b -> b -> Vector a -> b
-- | O(n) Right fold on non-empty vectors
foldr1 :: Unbox a => a -> a -> a -> Vector a -> a
-- | O(n) Right fold
foldr :: Unbox a => a -> b -> b -> b -> Vector a -> b
-- | O(n) Left fold on non-empty vectors with strict accumulator
foldl1' :: Unbox a => a -> a -> a -> Vector a -> a
-- | O(n) Left fold with strict accumulator
foldl' :: Unbox b => a -> b -> a -> a -> Vector b -> a
-- | O(n) Left fold on non-empty vectors
foldl1 :: Unbox a => a -> a -> a -> Vector a -> a
-- | O(n) Left fold
foldl :: Unbox b => a -> b -> a -> a -> Vector b -> a
-- | O(n) Yield the indices of all occurences of the given element
-- in ascending order. This is a specialised version of
-- findIndices.
elemIndices :: (Unbox a, Eq a) => a -> Vector a -> Vector Int
-- | O(n) Yield Just the index of the first occurence of the
-- given element or Nothing if the vector does not contain the
-- element. This is a specialised version of findIndex.
elemIndex :: (Unbox a, Eq a) => a -> Vector a -> Maybe Int
-- | O(n) Yield the indices of elements satisfying the predicate in
-- ascending order.
findIndices :: Unbox a => a -> Bool -> Vector a -> Vector Int
-- | O(n) Yield Just the index of the first element matching
-- the predicate or Nothing if no such element exists.
findIndex :: Unbox a => a -> Bool -> Vector a -> Maybe Int
-- | O(n) Yield Just the first element matching the predicate
-- or Nothing if no such element exists.
find :: Unbox a => a -> Bool -> Vector a -> Maybe a
-- | O(n) Check if the vector does not contain an element (inverse
-- of elem)
notElem :: (Unbox a, Eq a) => a -> Vector a -> Bool
infix 4 `notElem`
-- | O(n) Check if the vector contains an element
elem :: (Unbox a, Eq a) => a -> Vector a -> Bool
infix 4 `elem`
-- | O(n) Split the vector into the longest prefix of elements that
-- do not satisfy the predicate and the rest without copying.
break :: Unbox a => a -> Bool -> Vector a -> (Vector a, Vector a)
-- | O(n) Split the vector into the longest prefix of elements that
-- satisfy the predicate and the rest without copying.
span :: Unbox a => a -> Bool -> Vector a -> (Vector a, Vector a)
-- | O(n) Split the vector in two parts, the first one containing
-- those elements that satisfy the predicate and the second one those
-- that don't. The order of the elements is not preserved but the
-- operation is often faster than partition.
unstablePartition :: Unbox a => a -> Bool -> Vector a -> (Vector a, Vector a)
-- | O(n) Split the vector in two parts, the first one containing
-- those elements that satisfy the predicate and the second one those
-- that don't. The relative order of the elements is preserved at the
-- cost of a sometimes reduced performance compared to
-- unstablePartition.
partition :: Unbox a => a -> Bool -> Vector a -> (Vector a, Vector a)
-- | O(n) Drop the longest prefix of elements that satisfy the
-- predicate without copying.
dropWhile :: Unbox a => a -> Bool -> Vector a -> Vector a
-- | O(n) Yield the longest prefix of elements satisfying the
-- predicate without copying.
takeWhile :: Unbox a => a -> Bool -> Vector a -> Vector a
-- | O(n) Drop elements that do not satisfy the monadic predicate
filterM :: (Monad m, Unbox a) => a -> m Bool -> Vector a -> m Vector a
-- | O(n) Drop elements when predicate, applied to index and value,
-- returns Nothing
imapMaybe :: (Unbox a, Unbox b) => Int -> a -> Maybe b -> Vector a -> Vector b
-- | O(n) Drop elements when predicate returns Nothing
mapMaybe :: (Unbox a, Unbox b) => a -> Maybe b -> Vector a -> Vector b
-- | O(n) Drop elements that do not satisfy the predicate which is
-- applied to values and their indices
ifilter :: Unbox a => Int -> a -> Bool -> Vector a -> Vector a
-- | O(n) Drop repeated adjacent elements.
uniq :: (Unbox a, Eq a) => Vector a -> Vector a
-- | O(n) Drop elements that do not satisfy the predicate
filter :: Unbox a => a -> Bool -> Vector a -> Vector a
-- | O(min(m,n)) Zip the two vectors with a monadic action that also
-- takes the element index and ignore the results
izipWithM_ :: (Monad m, Unbox a, Unbox b) => Int -> a -> b -> m c -> Vector a -> Vector b -> m ()
-- | O(min(m,n)) Zip the two vectors with the monadic action and
-- ignore the results
zipWithM_ :: (Monad m, Unbox a, Unbox b) => a -> b -> m c -> Vector a -> Vector b -> m ()
-- | O(min(m,n)) Zip the two vectors with a monadic action that also
-- takes the element index and yield a vector of results
izipWithM :: (Monad m, Unbox a, Unbox b, Unbox c) => Int -> a -> b -> m c -> Vector a -> Vector b -> m Vector c
-- | O(min(m,n)) Zip the two vectors with the monadic action and
-- yield a vector of results
zipWithM :: (Monad m, Unbox a, Unbox b, Unbox c) => a -> b -> m c -> Vector a -> Vector b -> m Vector c
izipWith6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => Int -> a -> b -> c -> d -> e -> f -> g -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
izipWith5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Int -> a -> b -> c -> d -> e -> f -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
izipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Int -> a -> b -> c -> d -> e -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
-- | Zip three vectors and their indices with the given function.
izipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Int -> a -> b -> c -> d -> Vector a -> Vector b -> Vector c -> Vector d
-- | O(min(m,n)) Zip two vectors with a function that also takes the
-- elements' indices.
izipWith :: (Unbox a, Unbox b, Unbox c) => Int -> a -> b -> c -> Vector a -> Vector b -> Vector c
zipWith6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => a -> b -> c -> d -> e -> f -> g -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
zipWith5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => a -> b -> c -> d -> e -> f -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
zipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => a -> b -> c -> d -> e -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
-- | Zip three vectors with the given function.
zipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => a -> b -> c -> d -> Vector a -> Vector b -> Vector c -> Vector d
-- | O(min(m,n)) Zip two vectors with the given function.
zipWith :: (Unbox a, Unbox b, Unbox c) => a -> b -> c -> Vector a -> Vector b -> Vector c
-- | O(n) Apply the monadic action to all elements of a vector and
-- ignore the results. Equivalent to flip mapM_.
forM_ :: (Monad m, Unbox a) => Vector a -> a -> m b -> m ()
-- | O(n) Apply the monadic action to all elements of the vector,
-- yielding a vector of results. Equivalent to flip mapM.
forM :: (Monad m, Unbox a, Unbox b) => Vector a -> a -> m b -> m Vector b
-- | O(n) Apply the monadic action to every element of a vector and
-- its index, ignoring the results
imapM_ :: (Monad m, Unbox a) => Int -> a -> m b -> Vector a -> m ()
-- | O(n) Apply the monadic action to all elements of a vector and
-- ignore the results
mapM_ :: (Monad m, Unbox a) => a -> m b -> Vector a -> m ()
-- | O(n) Apply the monadic action to every element of a vector and
-- its index, yielding a vector of results
imapM :: (Monad m, Unbox a, Unbox b) => Int -> a -> m b -> Vector a -> m Vector b
-- | O(n) Apply the monadic action to all elements of the vector,
-- yielding a vector of results
mapM :: (Monad m, Unbox a, Unbox b) => a -> m b -> Vector a -> m Vector b
-- | Map a function over a vector and concatenate the results.
concatMap :: (Unbox a, Unbox b) => a -> Vector b -> Vector a -> Vector b
-- | O(n) Apply a function to every element of a vector and its
-- index
imap :: (Unbox a, Unbox b) => Int -> a -> b -> Vector a -> Vector b
-- | O(n) Map a function over a vector
map :: (Unbox a, Unbox b) => a -> b -> Vector a -> Vector b
-- | O(n) Pair each element in a vector with its index
indexed :: Unbox a => Vector a -> Vector (Int, a)
-- | Apply a destructive operation to a vector. The operation will be
-- performed in place if it is safe to do so and will modify a copy of
-- the vector otherwise.
--
--
-- modify (\v -> write v 0 'x') (replicate 3 'a') = <'x','a','a'>
--
modify :: Unbox a => forall s. () => MVector s a -> ST s () -> Vector a -> Vector a
-- | Same as backpermute but without bounds checking.
unsafeBackpermute :: Unbox a => Vector a -> Vector Int -> Vector a
-- | O(n) Yield the vector obtained by replacing each element
-- i of the index vector by xs!i. This is
-- equivalent to map (xs!) is but is often much
-- more efficient.
--
--
-- backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>
--
backpermute :: Unbox a => Vector a -> Vector Int -> Vector a
-- | O(n) Reverse a vector
reverse :: Unbox a => Vector a -> Vector a
-- | Same as accumulate_ but without bounds checking.
unsafeAccumulate_ :: (Unbox a, Unbox b) => a -> b -> a -> Vector a -> Vector Int -> Vector b -> Vector a
-- | Same as accumulate but without bounds checking.
unsafeAccumulate :: (Unbox a, Unbox b) => a -> b -> a -> Vector a -> Vector (Int, b) -> Vector a
-- | Same as accum but without bounds checking.
unsafeAccum :: Unbox a => a -> b -> a -> Vector a -> [(Int, b)] -> Vector a
-- | O(m+min(n1,n2)) For each index i from the index vector
-- and the corresponding value b from the the value vector,
-- replace the element of the initial vector at position i by
-- f a b.
--
--
-- accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>
--
--
-- The function accumulate provides the same functionality and is
-- usually more convenient.
--
--
-- accumulate_ f as is bs = accumulate f as (zip is bs)
--
accumulate_ :: (Unbox a, Unbox b) => a -> b -> a -> Vector a -> Vector Int -> Vector b -> Vector a
-- | O(m+n) For each pair (i,b) from the vector of pairs,
-- replace the vector element a at position i by f
-- a b.
--
--
-- accumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>
--
accumulate :: (Unbox a, Unbox b) => a -> b -> a -> Vector a -> Vector (Int, b) -> Vector a
-- | O(m+n) For each pair (i,b) from the list, replace the
-- vector element a at position i by f a b.
--
--
-- accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>
--
accum :: Unbox a => a -> b -> a -> Vector a -> [(Int, b)] -> Vector a
-- | Same as update_ but without bounds checking.
unsafeUpdate_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a
-- | Same as update but without bounds checking.
unsafeUpdate :: Unbox a => Vector a -> Vector (Int, a) -> Vector a
-- | Same as (//) but without bounds checking.
unsafeUpd :: Unbox a => Vector a -> [(Int, a)] -> Vector a
-- | O(m+min(n1,n2)) For each index i from the index vector
-- and the corresponding value a from the value vector, replace
-- the element of the initial vector at position i by
-- a.
--
--
-- update_ <5,9,2,7> <2,0,2> <1,3,8> = <3,9,8,7>
--
--
-- The function update provides the same functionality and is
-- usually more convenient.
--
--
-- update_ xs is ys = update xs (zip is ys)
--
update_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a
-- | O(m+n) For each pair (i,a) from the vector of
-- index/value pairs, replace the vector element at position i
-- by a.
--
--
-- update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>
--
update :: Unbox a => Vector a -> Vector (Int, a) -> Vector a
-- | O(m+n) For each pair (i,a) from the list, replace the
-- vector element at position i by a.
--
--
-- <5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>
--
(//) :: Unbox a => Vector a -> [(Int, a)] -> Vector a
-- | O(n) Yield the argument but force it not to retain any extra
-- memory, possibly by copying it.
--
-- This is especially useful when dealing with slices. For example:
--
--
-- force (slice 0 2 <huge vector>)
--
--
-- Here, the slice retains a reference to the huge vector. Forcing it
-- creates a copy of just the elements that belong to the slice and
-- allows the huge vector to be garbage collected.
force :: Unbox a => Vector a -> Vector a
-- | Execute the monadic action and freeze the resulting vectors.
createT :: (Traversable f, Unbox a) => forall s. () => ST s f MVector s a -> f Vector a
-- | Execute the monadic action and freeze the resulting vector.
--
--
-- create (do { v <- new 2; write v 0 'a'; write v 1 'b'; return v }) = <a,b>
--
create :: Unbox a => forall s. () => ST s MVector s a -> Vector a
-- | O(n) Apply monadic function n times to value. Zeroth element is
-- original value.
iterateNM :: (Monad m, Unbox a) => Int -> a -> m a -> a -> m Vector a
-- | O(n) Construct a vector of the given length by applying the
-- monadic action to each index
generateM :: (Monad m, Unbox a) => Int -> Int -> m a -> m Vector a
-- | O(n) Execute the monadic action the given number of times and
-- store the results in a vector.
replicateM :: (Monad m, Unbox a) => Int -> m a -> m Vector a
-- | O(n) Concatenate all vectors in the list
concat :: Unbox a => [Vector a] -> Vector a
-- | O(m+n) Concatenate two vectors
(++) :: Unbox a => Vector a -> Vector a -> Vector a
infixr 5 ++
-- | O(n) Append an element
snoc :: Unbox a => Vector a -> a -> Vector a
-- | O(n) Prepend an element
cons :: Unbox a => a -> Vector a -> Vector a
-- | O(n) Enumerate values from x to y with a
-- specific step z.
--
-- WARNING: This operation can be very inefficient. If at all
-- possible, use enumFromStepN instead.
enumFromThenTo :: (Unbox a, Enum a) => a -> a -> a -> Vector a
-- | O(n) Enumerate values from x to y.
--
-- WARNING: This operation can be very inefficient. If at all
-- possible, use enumFromN instead.
enumFromTo :: (Unbox a, Enum a) => a -> a -> Vector a
-- | O(n) Yield a vector of the given length containing the values
-- x, x+y, x+y+y etc. This operations is
-- usually more efficient than enumFromThenTo.
--
--
-- enumFromStepN 1 0.1 5 = <1,1.1,1.2,1.3,1.4>
--
enumFromStepN :: (Unbox a, Num a) => a -> a -> Int -> Vector a
-- | O(n) Yield a vector of the given length containing the values
-- x, x+1 etc. This operation is usually more efficient
-- than enumFromTo.
--
--
-- enumFromN 5 3 = <5,6,7>
--
enumFromN :: (Unbox a, Num a) => a -> Int -> Vector a
-- | O(n) Construct a vector with n elements from right to
-- left by repeatedly applying the generator function to the already
-- constructed part of the vector.
--
--
-- constructrN 3 f = let a = f <> ; b = f<a> ; c = f <b,a> in f <c,b,a>
--
constructrN :: Unbox a => Int -> Vector a -> a -> Vector a
-- | O(n) Construct a vector with n elements by repeatedly
-- applying the generator function to the already constructed part of the
-- vector.
--
--
-- constructN 3 f = let a = f <> ; b = f <a> ; c = f <a,b> in f <a,b,c>
--
constructN :: Unbox a => Int -> Vector a -> a -> Vector a
-- | O(n) Construct a vector by repeatedly applying the monadic
-- 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.
unfoldrNM :: (Monad m, Unbox a) => Int -> b -> m Maybe (a, b) -> b -> m Vector a
-- | O(n) Construct a vector by repeatedly applying the monadic
-- 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.
unfoldrM :: (Monad m, Unbox a) => b -> m Maybe (a, b) -> b -> m Vector a
-- | O(n) Construct a vector 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.
--
--
-- unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8>
--
unfoldrN :: Unbox a => Int -> b -> Maybe (a, b) -> b -> Vector a
-- | O(n) Construct a vector 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.
--
--
-- unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10
-- = <10,9,8,7,6,5,4,3,2,1>
--
unfoldr :: Unbox a => b -> Maybe (a, b) -> b -> Vector a
-- | O(n) Apply function n times to value. Zeroth element is
-- original value.
iterateN :: Unbox a => Int -> a -> a -> a -> Vector a
-- | O(n) Construct a vector of the given length by applying the
-- function to each index
generate :: Unbox a => Int -> Int -> a -> Vector a
-- | O(n) Vector of the given length with the same value in each
-- position
replicate :: Unbox a => Int -> a -> Vector a
-- | O(1) Vector with exactly one element
singleton :: Unbox a => a -> Vector a
-- | O(1) Empty vector
empty :: Unbox a => Vector a
-- | O(1) Yield all but the first n elements without
-- copying. The vector must contain at least n elements but this
-- is not checked.
unsafeDrop :: Unbox a => Int -> Vector a -> Vector a
-- | O(1) Yield the first n elements without copying. The
-- vector must contain at least n elements but this is not
-- checked.
unsafeTake :: Unbox a => Int -> Vector a -> Vector a
-- | O(1) Yield all but the first element without copying. The
-- vector may not be empty but this is not checked.
unsafeTail :: Unbox a => Vector a -> Vector a
-- | O(1) Yield all but the last element without copying. The vector
-- may not be empty but this is not checked.
unsafeInit :: Unbox a => Vector a -> Vector a
-- | O(1) Yield a slice of the vector without copying. The vector
-- must contain at least i+n elements but this is not checked.
unsafeSlice :: Unbox a => Int -> Int -> Vector a -> Vector a
-- | O(1) Yield the first n elements paired with the
-- remainder without copying.
--
-- Note that splitAt n v is equivalent to
-- (take n v, drop n v) but slightly more
-- efficient.
splitAt :: Unbox a => Int -> Vector a -> (Vector a, Vector a)
-- | O(1) Yield all but the first n elements without
-- copying. The vector may contain less than n elements in which
-- case an empty vector is returned.
drop :: Unbox a => Int -> Vector a -> Vector a
-- | O(1) Yield at the first n elements without copying.
-- The vector may contain less than n elements in which case it
-- is returned unchanged.
take :: Unbox a => Int -> Vector a -> Vector a
-- | O(1) Yield all but the first element without copying. The
-- vector may not be empty.
tail :: Unbox a => Vector a -> Vector a
-- | O(1) Yield all but the last element without copying. The vector
-- may not be empty.
init :: Unbox a => Vector a -> Vector a
-- | O(1) Yield a slice of the vector without copying it. The vector
-- must contain at least i+n elements.
slice :: Unbox a => Int -> Int -> Vector a -> Vector a
-- | O(1) Last element in a monad without checking for empty
-- vectors. See indexM for an explanation of why this is useful.
unsafeLastM :: (Unbox a, Monad m) => Vector a -> m a
-- | O(1) First element in a monad without checking for empty
-- vectors. See indexM for an explanation of why this is useful.
unsafeHeadM :: (Unbox a, Monad m) => Vector a -> m a
-- | O(1) Indexing in a monad without bounds checks. See
-- indexM for an explanation of why this is useful.
unsafeIndexM :: (Unbox a, Monad m) => Vector a -> Int -> m a
-- | O(1) Last element of a vector in a monad. See indexM for
-- an explanation of why this is useful.
lastM :: (Unbox a, Monad m) => Vector a -> m a
-- | O(1) First element of a vector in a monad. See indexM
-- for an explanation of why this is useful.
headM :: (Unbox a, Monad m) => Vector a -> m a
-- | O(1) Indexing in a monad.
--
-- The monad allows operations to be strict in the vector when necessary.
-- Suppose vector copying is implemented like this:
--
--
-- copy mv v = ... write mv i (v ! i) ...
--
--
-- For lazy vectors, v ! i would 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.
indexM :: (Unbox a, Monad m) => Vector a -> Int -> m a
-- | O(1) Last element without checking if the vector is empty
unsafeLast :: Unbox a => Vector a -> a
-- | O(1) First element without checking if the vector is empty
unsafeHead :: Unbox a => Vector a -> a
-- | O(1) Unsafe indexing without bounds checking
unsafeIndex :: Unbox a => Vector a -> Int -> a
-- | O(1) Last element
last :: Unbox a => Vector a -> a
-- | O(1) First element
head :: Unbox a => Vector a -> a
-- | O(1) Safe indexing
(!?) :: Unbox a => Vector a -> Int -> Maybe a
-- | O(1) Indexing
(!) :: Unbox a => Vector a -> Int -> a
-- | O(1) Test whether a vector is empty
null :: Unbox a => Vector a -> Bool
-- | O(1) Yield the length of the vector
length :: Unbox a => Vector a -> Int
-- | O(n) Convert different vector types
convert :: (Vector v a, Vector w a) => v a -> w a
-- | O(1)
index :: Vector v a => v a -> Int -> Maybe a
-- | O(n)
replace :: (Vector v a, Eq a) => a -> v a -> v a -> v a
commonPrefixes :: (Vector v a, Eq a) => v a -> v a -> Maybe (v a, v a, v a)