rio-0.1.14.0: A standard library for Haskell

Safe HaskellNone
LanguageHaskell2010

RIO.Vector

Contents

Description

Generic Vector interface. Import as:

import qualified RIO.Vector as V

This module does not export any partial or unsafe functions. For those, see RIO.Vector.Partial and RIO.Vector.Unsafe

Synopsis

Immutable vectors

class MVector (Mutable v) a => Vector (v :: Type -> Type) a #

Instances
Storable a => Vector Vector a 
Instance details

Defined in Data.Vector.Storable

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) a -> m (Vector a) #

basicUnsafeThaw :: PrimMonad m => Vector a -> m (Mutable Vector (PrimState m) a) #

basicLength :: Vector a -> Int #

basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a #

basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) a -> Vector a -> m () #

elemseq :: Vector a -> a -> b -> b #

Vector Vector Bool 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Char 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Double 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Float 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Int 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Int8 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Int16 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Int32 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Int64 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Word 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Word8 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Word16 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Word32 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector Word64 
Instance details

Defined in Data.Vector.Unboxed.Base

Vector Vector () 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) () -> m (Vector ()) #

basicUnsafeThaw :: PrimMonad m => Vector () -> m (Mutable Vector (PrimState m) ()) #

basicLength :: Vector () -> Int #

basicUnsafeSlice :: Int -> Int -> Vector () -> Vector () #

basicUnsafeIndexM :: Monad m => Vector () -> Int -> m () #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) () -> Vector () -> m () #

elemseq :: Vector () -> () -> b -> b #

Vector Vector Any 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Any -> m (Vector Any) #

basicUnsafeThaw :: PrimMonad m => Vector Any -> m (Mutable Vector (PrimState m) Any) #

basicLength :: Vector Any -> Int #

basicUnsafeSlice :: Int -> Int -> Vector Any -> Vector Any #

basicUnsafeIndexM :: Monad m => Vector Any -> Int -> m Any #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Any -> Vector Any -> m () #

elemseq :: Vector Any -> Any -> b -> b #

Vector Vector All 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) All -> m (Vector All) #

basicUnsafeThaw :: PrimMonad m => Vector All -> m (Mutable Vector (PrimState m) All) #

basicLength :: Vector All -> Int #

basicUnsafeSlice :: Int -> Int -> Vector All -> Vector All #

basicUnsafeIndexM :: Monad m => Vector All -> Int -> m All #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) All -> Vector All -> m () #

elemseq :: Vector All -> All -> b -> b #

Prim a => Vector Vector a 
Instance details

Defined in Data.Vector.Primitive

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) a -> m (Vector a) #

basicUnsafeThaw :: PrimMonad m => Vector a -> m (Mutable Vector (PrimState m) a) #

basicLength :: Vector a -> Int #

basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a #

basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) a -> Vector a -> m () #

elemseq :: Vector a -> a -> b -> b #

Vector Vector a 
Instance details

Defined in Data.Vector

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) a -> m (Vector a) #

basicUnsafeThaw :: PrimMonad m => Vector a -> m (Mutable Vector (PrimState m) a) #

basicLength :: Vector a -> Int #

basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a #

basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) a -> Vector a -> m () #

elemseq :: Vector a -> a -> b -> b #

Unbox a => Vector Vector (Identity a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Identity a) -> m (Vector (Identity a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Identity a) -> m (Mutable Vector (PrimState m) (Identity a)) #

basicLength :: Vector (Identity a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Identity a) -> Vector (Identity a) #

basicUnsafeIndexM :: Monad m => Vector (Identity a) -> Int -> m (Identity a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Identity a) -> Vector (Identity a) -> m () #

elemseq :: Vector (Identity a) -> Identity a -> b -> b #

Unbox a => Vector Vector (Product a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Product a) -> m (Vector (Product a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Product a) -> m (Mutable Vector (PrimState m) (Product a)) #

basicLength :: Vector (Product a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Product a) -> Vector (Product a) #

basicUnsafeIndexM :: Monad m => Vector (Product a) -> Int -> m (Product a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Product a) -> Vector (Product a) -> m () #

elemseq :: Vector (Product a) -> Product a -> b -> b #

Unbox a => Vector Vector (Sum a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Sum a) -> m (Vector (Sum a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Sum a) -> m (Mutable Vector (PrimState m) (Sum a)) #

basicLength :: Vector (Sum a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Sum a) -> Vector (Sum a) #

basicUnsafeIndexM :: Monad m => Vector (Sum a) -> Int -> m (Sum a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Sum a) -> Vector (Sum a) -> m () #

elemseq :: Vector (Sum a) -> Sum a -> b -> b #

Unbox a => Vector Vector (Dual a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Dual a) -> m (Vector (Dual a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Dual a) -> m (Mutable Vector (PrimState m) (Dual a)) #

basicLength :: Vector (Dual a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Dual a) -> Vector (Dual a) #

basicUnsafeIndexM :: Monad m => Vector (Dual a) -> Int -> m (Dual a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Dual a) -> Vector (Dual a) -> m () #

elemseq :: Vector (Dual a) -> Dual a -> b -> b #

Unbox a => Vector Vector (Complex a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> m (Vector (Complex a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Complex a) -> m (Mutable Vector (PrimState m) (Complex a)) #

basicLength :: Vector (Complex a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a) #

basicUnsafeIndexM :: Monad m => Vector (Complex a) -> Int -> m (Complex a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> Vector (Complex a) -> m () #

elemseq :: Vector (Complex a) -> Complex a -> b -> b #

Unbox a => Vector Vector (First a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (First a) -> m (Vector (First a)) #

basicUnsafeThaw :: PrimMonad m => Vector (First a) -> m (Mutable Vector (PrimState m) (First a)) #

basicLength :: Vector (First a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (First a) -> Vector (First a) #

basicUnsafeIndexM :: Monad m => Vector (First a) -> Int -> m (First a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (First a) -> Vector (First a) -> m () #

elemseq :: Vector (First a) -> First a -> b -> b #

Unbox a => Vector Vector (Last a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Last a) -> m (Vector (Last a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Last a) -> m (Mutable Vector (PrimState m) (Last a)) #

basicLength :: Vector (Last a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Last a) -> Vector (Last a) #

basicUnsafeIndexM :: Monad m => Vector (Last a) -> Int -> m (Last a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Last a) -> Vector (Last a) -> m () #

elemseq :: Vector (Last a) -> Last a -> b -> b #

Unbox a => Vector Vector (Max a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Max a) -> m (Vector (Max a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Max a) -> m (Mutable Vector (PrimState m) (Max a)) #

basicLength :: Vector (Max a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Max a) -> Vector (Max a) #

basicUnsafeIndexM :: Monad m => Vector (Max a) -> Int -> m (Max a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Max a) -> Vector (Max a) -> m () #

elemseq :: Vector (Max a) -> Max a -> b -> b #

Unbox a => Vector Vector (Min a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Min a) -> m (Vector (Min a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Min a) -> m (Mutable Vector (PrimState m) (Min a)) #

basicLength :: Vector (Min a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Min a) -> Vector (Min a) #

basicUnsafeIndexM :: Monad m => Vector (Min a) -> Int -> m (Min a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Min a) -> Vector (Min a) -> m () #

elemseq :: Vector (Min a) -> Min a -> b -> b #

Unbox a => Vector Vector (WrappedMonoid a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (WrappedMonoid a) -> m (Vector (WrappedMonoid a)) #

basicUnsafeThaw :: PrimMonad m => Vector (WrappedMonoid a) -> m (Mutable Vector (PrimState m) (WrappedMonoid a)) #

basicLength :: Vector (WrappedMonoid a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (WrappedMonoid a) -> Vector (WrappedMonoid a) #

basicUnsafeIndexM :: Monad m => Vector (WrappedMonoid a) -> Int -> m (WrappedMonoid a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (WrappedMonoid a) -> Vector (WrappedMonoid a) -> m () #

elemseq :: Vector (WrappedMonoid a) -> WrappedMonoid a -> b -> b #

Unbox a => Vector Vector (Down a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Down a) -> m (Vector (Down a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Down a) -> m (Mutable Vector (PrimState m) (Down a)) #

basicLength :: Vector (Down a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Down a) -> Vector (Down a) #

basicUnsafeIndexM :: Monad m => Vector (Down a) -> Int -> m (Down a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Down a) -> Vector (Down a) -> m () #

elemseq :: Vector (Down a) -> Down a -> b -> b #

(Unbox a, Unbox b) => Vector Vector (a, b) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> m (Vector (a, b)) #

basicUnsafeThaw :: PrimMonad m => Vector (a, b) -> m (Mutable Vector (PrimState m) (a, b)) #

basicLength :: Vector (a, b) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (a, b) -> Vector (a, b) #

basicUnsafeIndexM :: Monad m => Vector (a, b) -> Int -> m (a, b) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> Vector (a, b) -> m () #

elemseq :: Vector (a, b) -> (a, b) -> b0 -> b0 #

(Unbox a, Unbox b) => Vector Vector (Arg a b) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Arg a b) -> m (Vector (Arg a b)) #

basicUnsafeThaw :: PrimMonad m => Vector (Arg a b) -> m (Mutable Vector (PrimState m) (Arg a b)) #

basicLength :: Vector (Arg a b) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Arg a b) -> Vector (Arg a b) #

basicUnsafeIndexM :: Monad m => Vector (Arg a b) -> Int -> m (Arg a b) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Arg a b) -> Vector (Arg a b) -> m () #

elemseq :: Vector (Arg a b) -> Arg a b -> b0 -> b0 #

(Unbox a, Unbox b, Unbox c) => Vector Vector (a, b, c) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> m (Vector (a, b, c)) #

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c) -> m (Mutable Vector (PrimState m) (a, b, c)) #

basicLength :: Vector (a, b, c) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c) -> Vector (a, b, c) #

basicUnsafeIndexM :: Monad m => Vector (a, b, c) -> Int -> m (a, b, c) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> Vector (a, b, c) -> m () #

elemseq :: Vector (a, b, c) -> (a, b, c) -> b0 -> b0 #

Unbox a => Vector Vector (Const a b) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> m (Vector (Const a b)) #

basicUnsafeThaw :: PrimMonad m => Vector (Const a b) -> m (Mutable Vector (PrimState m) (Const a b)) #

basicLength :: Vector (Const a b) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b) #

basicUnsafeIndexM :: Monad m => Vector (Const a b) -> Int -> m (Const a b) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> Vector (Const a b) -> m () #

elemseq :: Vector (Const a b) -> Const a b -> b0 -> b0 #

Unbox (f a) => Vector Vector (Alt f a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Alt f a) -> m (Vector (Alt f a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Alt f a) -> m (Mutable Vector (PrimState m) (Alt f a)) #

basicLength :: Vector (Alt f a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Alt f a) -> Vector (Alt f a) #

basicUnsafeIndexM :: Monad m => Vector (Alt f a) -> Int -> m (Alt f a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Alt f a) -> Vector (Alt f a) -> m () #

elemseq :: Vector (Alt f a) -> Alt f a -> b -> b #

(Unbox a, Unbox b, Unbox c, Unbox d) => Vector Vector (a, b, c, d) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> m (Vector (a, b, c, d)) #

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d) -> m (Mutable Vector (PrimState m) (a, b, c, d)) #

basicLength :: Vector (a, b, c, d) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d) -> Vector (a, b, c, d) #

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d) -> Int -> m (a, b, c, d) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> Vector (a, b, c, d) -> m () #

elemseq :: Vector (a, b, c, d) -> (a, b, c, d) -> b0 -> b0 #

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector Vector (a, b, c, d, e) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> m (Vector (a, b, c, d, e)) #

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e) -> m (Mutable Vector (PrimState m) (a, b, c, d, e)) #

basicLength :: Vector (a, b, c, d, e) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e) -> Vector (a, b, c, d, e) #

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e) -> Int -> m (a, b, c, d, e) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> Vector (a, b, c, d, e) -> m () #

elemseq :: Vector (a, b, c, d, e) -> (a, b, c, d, e) -> b0 -> b0 #

Unbox (f (g a)) => Vector Vector (Compose f g a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Compose f g a) -> m (Vector (Compose f g a)) #

basicUnsafeThaw :: PrimMonad m => Vector (Compose f g a) -> m (Mutable Vector (PrimState m) (Compose f g a)) #

basicLength :: Vector (Compose f g a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Compose f g a) -> Vector (Compose f g a) #

basicUnsafeIndexM :: Monad m => Vector (Compose f g a) -> Int -> m (Compose f g a) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Compose f g a) -> Vector (Compose f g a) -> m () #

elemseq :: Vector (Compose f g a) -> Compose f g a -> b -> b #

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector Vector (a, b, c, d, e, f) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> m (Vector (a, b, c, d, e, f)) #

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e, f) -> m (Mutable Vector (PrimState m) (a, b, c, d, e, f)) #

basicLength :: Vector (a, b, c, d, e, f) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) #

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f) #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> m () #

elemseq :: Vector (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> b0 -> b0 #

Accessors

Length information

length :: Vector v a => v a -> Int #

null :: Vector v a => v a -> Bool #

Indexing

(!?) :: Vector v a => v a -> Int -> Maybe a #

Extracting subvectors

slice :: Vector v a => Int -> Int -> v a -> v a #

take :: Vector v a => Int -> v a -> v a #

drop :: Vector v a => Int -> v a -> v a #

splitAt :: Vector v a => Int -> v a -> (v a, v a) #

Construction

Initialisation

empty :: Vector v a => v a #

singleton :: Vector v a => a -> v a #

replicate :: Vector v a => Int -> a -> v a #

generate :: Vector v a => Int -> (Int -> a) -> v a #

iterateN :: Vector v a => Int -> (a -> a) -> a -> v a #

Monadic initialisation

replicateM :: (Monad m, Vector v a) => Int -> m a -> m (v a) #

generateM :: (Monad m, Vector v a) => Int -> (Int -> m a) -> m (v a) #

iterateNM :: (Monad m, Vector v a) => Int -> (a -> m a) -> a -> m (v a) #

create :: Vector v a => (forall s. ST s (Mutable v s a)) -> v a #

createT :: (Traversable f, Vector v a) => (forall s. ST s (f (Mutable v s a))) -> f (v a) #

Unfolding

unfoldr :: Vector v a => (b -> Maybe (a, b)) -> b -> v a #

unfoldrN :: Vector v a => Int -> (b -> Maybe (a, b)) -> b -> v a #

unfoldrM :: (Monad m, Vector v a) => (b -> m (Maybe (a, b))) -> b -> m (v a) #

unfoldrNM :: (Monad m, Vector v a) => Int -> (b -> m (Maybe (a, b))) -> b -> m (v a) #

constructN :: Vector v a => Int -> (v a -> a) -> v a #

constructrN :: Vector v a => Int -> (v a -> a) -> v a #

Enumeration

enumFromN :: (Vector v a, Num a) => a -> Int -> v a #

enumFromStepN :: (Vector v a, Num a) => a -> a -> Int -> v a #

enumFromTo :: (Vector v a, Enum a) => a -> a -> v a #

enumFromThenTo :: (Vector v a, Enum a) => a -> a -> a -> v a #

Concatenation

cons :: Vector v a => a -> v a -> v a #

snoc :: Vector v a => v a -> a -> v a #

(++) :: Vector v a => v a -> v a -> v a #

concat :: Vector v a => [v a] -> v a #

concatNE :: Vector v a => NonEmpty (v a) -> v a #

Restricting memory usage

force :: Vector v a => v a -> v a #

Modifying vectors

Permutations

reverse :: Vector v a => v a -> v a #

Safe destructive update

modify :: Vector v a => (forall s. Mutable v s a -> ST s ()) -> v a -> v a #

Elementwise operations

Indexing

indexed :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) #

Mapping

map :: (Vector v a, Vector v b) => (a -> b) -> v a -> v b #

imap :: (Vector v a, Vector v b) => (Int -> a -> b) -> v a -> v b #

concatMap :: (Vector v a, Vector v b) => (a -> v b) -> v a -> v b #

Monadic mapping

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

imapM :: (Monad m, Vector v a, Vector v b) => (Int -> a -> m b) -> v a -> m (v b) #

mapM_ :: (Monad m, Vector v a) => (a -> m b) -> v a -> m () #

imapM_ :: (Monad m, Vector v a) => (Int -> a -> m b) -> v a -> m () #

forM :: (Monad m, Vector v a, Vector v b) => v a -> (a -> m b) -> m (v b) #

forM_ :: (Monad m, Vector v a) => v a -> (a -> m b) -> m () #

Zipping

zipWith :: (Vector v a, Vector v b, Vector v c) => (a -> b -> c) -> v a -> v b -> v c #

zipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (a -> b -> c -> d) -> v a -> v b -> v c -> v d #

zipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e #

zipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f) => (a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d -> v e -> v f #

zipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g) => (a -> b -> c -> d -> e -> f -> g) -> v a -> v b -> v c -> v d -> v e -> v f -> v g #

izipWith :: (Vector v a, Vector v b, Vector v c) => (Int -> a -> b -> c) -> v a -> v b -> v c #

izipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (Int -> a -> b -> c -> d) -> v a -> v b -> v c -> v d #

izipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (Int -> a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e #

izipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f) => (Int -> a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d -> v e -> v f #

izipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g) => (Int -> a -> b -> c -> d -> e -> f -> g) -> v a -> v b -> v c -> v d -> v e -> v f -> v g #

zip :: (Vector v a, Vector v b, Vector v (a, b)) => v a -> v b -> v (a, b) #

zip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => v a -> v b -> v c -> v (a, b, c) #

zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => v a -> v b -> v c -> v d -> v (a, b, c, d) #

zip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => v a -> v b -> v c -> v d -> v e -> v (a, b, c, d, e) #

zip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v (a, b, c, d, e, f)) => v a -> v b -> v c -> v d -> v e -> v f -> v (a, b, c, d, e, f) #

Monadic zipping

zipWithM :: (Monad m, Vector v a, Vector v b, Vector v c) => (a -> b -> m c) -> v a -> v b -> m (v c) #

izipWithM :: (Monad m, Vector v a, Vector v b, Vector v c) => (Int -> a -> b -> m c) -> v a -> v b -> m (v c) #

zipWithM_ :: (Monad m, Vector v a, Vector v b) => (a -> b -> m c) -> v a -> v b -> m () #

izipWithM_ :: (Monad m, Vector v a, Vector v b) => (Int -> a -> b -> m c) -> v a -> v b -> m () #

Unzipping

unzip :: (Vector v a, Vector v b, Vector v (a, b)) => v (a, b) -> (v a, v b) #

unzip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => v (a, b, c) -> (v a, v b, v c) #

unzip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => v (a, b, c, d) -> (v a, v b, v c, v d) #

unzip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => v (a, b, c, d, e) -> (v a, v b, v c, v d, v e) #

unzip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v (a, b, c, d, e, f)) => v (a, b, c, d, e, f) -> (v a, v b, v c, v d, v e, v f) #

Working with predicates

Filtering

filter :: Vector v a => (a -> Bool) -> v a -> v a #

ifilter :: Vector v a => (Int -> a -> Bool) -> v a -> v a #

uniq :: (Vector v a, Eq a) => v a -> v a #

mapMaybe :: (Vector v a, Vector v b) => (a -> Maybe b) -> v a -> v b #

imapMaybe :: (Vector v a, Vector v b) => (Int -> a -> Maybe b) -> v a -> v b #

filterM :: (Monad m, Vector v a) => (a -> m Bool) -> v a -> m (v a) #

takeWhile :: Vector v a => (a -> Bool) -> v a -> v a #

dropWhile :: Vector v a => (a -> Bool) -> v a -> v a #

Partitioning

partition :: Vector v a => (a -> Bool) -> v a -> (v a, v a) #

unstablePartition :: Vector v a => (a -> Bool) -> v a -> (v a, v a) #

span :: Vector v a => (a -> Bool) -> v a -> (v a, v a) #

break :: Vector v a => (a -> Bool) -> v a -> (v a, v a) #

Searching

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

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

find :: Vector v a => (a -> Bool) -> v a -> Maybe a #

findIndex :: Vector v a => (a -> Bool) -> v a -> Maybe Int #

findIndices :: (Vector v a, Vector v Int) => (a -> Bool) -> v a -> v Int #

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

elemIndices :: (Vector v a, Vector v Int, Eq a) => a -> v a -> v Int #

Folding

foldl :: Vector v b => (a -> b -> a) -> a -> v b -> a #

foldl' :: Vector v b => (a -> b -> a) -> a -> v b -> a #

foldr :: Vector v a => (a -> b -> b) -> b -> v a -> b #

foldr' :: Vector v a => (a -> b -> b) -> b -> v a -> b #

ifoldl :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a #

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

ifoldr :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b #

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

Specialised folds

all :: Vector v a => (a -> Bool) -> v a -> Bool #

any :: Vector v a => (a -> Bool) -> v a -> Bool #

and :: Vector v Bool => v Bool -> Bool #

or :: Vector v Bool => v Bool -> Bool #

sum :: (Vector v a, Num a) => v a -> a #

product :: (Vector v a, Num a) => v a -> a #

Monadic folds

foldM :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a #

ifoldM :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> v b -> m a #

foldM' :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a #

ifoldM' :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> v b -> m a #

foldM_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m () #

ifoldM_ :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> v b -> m () #

foldM'_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m () #

ifoldM'_ :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> v b -> m () #

Monadic sequencing

sequence :: (Monad m, Vector v a, Vector v (m a)) => v (m a) -> m (v a) #

sequence_ :: (Monad m, Vector v (m a)) => v (m a) -> m () #

Prefix sums (scans)

prescanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a #

prescanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a #

postscanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a #

postscanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a #

scanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a #

scanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a #

iscanl :: (Vector v a, Vector v b) => (Int -> a -> b -> a) -> a -> v b -> v a #

iscanl' :: (Vector v a, Vector v b) => (Int -> a -> b -> a) -> a -> v b -> v a #

prescanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b #

prescanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b #

postscanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b #

postscanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b #

scanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b #

scanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b #

iscanr :: (Vector v a, Vector v b) => (Int -> a -> b -> b) -> b -> v a -> v b #

iscanr' :: (Vector v a, Vector v b) => (Int -> a -> b -> b) -> b -> v a -> v b #

Conversions

Lists

toList :: Vector v a => v a -> [a] #

fromList :: Vector v a => [a] -> v a #

fromListN :: Vector v a => Int -> [a] -> v a #

Different vector types

convert :: (Vector v a, Vector w a) => v a -> w a #

Mutable vectors

freeze :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m (v a) #

thaw :: (PrimMonad m, Vector v a) => v a -> m (Mutable v (PrimState m) a) #

copy :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m () #

Fusion support

Conversion to/from Bundles

stream :: Vector v a => v a -> Bundle v a #

unstream :: Vector v a => Bundle v a -> v a #

streamR :: Vector v a => v a -> Bundle u a #

unstreamR :: Vector v a => Bundle v a -> v a #

Recycling support

new :: Vector v a => New v a -> v a #

clone :: Vector v a => v a -> New v a #

Utilities

Comparisons

eq :: (Vector v a, Eq a) => v a -> v a -> Bool #

cmp :: (Vector v a, Ord a) => v a -> v a -> Ordering #

eqBy :: (Vector v a, Vector v b) => (a -> b -> Bool) -> v a -> v b -> Bool #

cmpBy :: (Vector v a, Vector v b) => (a -> b -> Ordering) -> v a -> v b -> Ordering #

Show and Read

showsPrec :: (Vector v a, Show a) => Int -> v a -> ShowS #

readPrec :: (Vector v a, Read a) => ReadPrec (v a) #

liftShowsPrec :: Vector v a => (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> v a -> ShowS #

liftReadsPrec :: Vector v a => (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (v a) #

Data and Typeable

gfoldl :: (Vector v a, Data a) => (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> v a -> c (v a) #

dataCast :: (Vector v a, Data a, Typeable v, Typeable t) => (forall d. Data d => c (t d)) -> Maybe (c (v a)) #

mkType :: String -> DataType #