Modulerio-0.1.25.0Haskell2010

RIO.Vector.Boxed

Boxed Vector. Import as:

import qualified RIO.Vector.Boxed as VB

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

Contents

Boxed vectors
Accessors
Length information
Indexing
Extracting subvectors
Construction
Initialisation
Monadic initialisation
Unfolding
Enumeration
Concatenation
Restricting memory usage
Modifying vectors
Permutations
Safe destructive update
Elementwise operations
Indexing
Mapping
Monadic mapping
Zipping
Monadic zipping
Unzipping
Working with predicates
Filtering
Partitioning
Searching
Folding
Specialised folds
Monadic folds
Monadic sequencing
Prefix sums (scans)
Conversions
Lists
Different vector types
Mutable vectors

Synopsis

data Vector
data MVector
value length
value null
value !?
value slice
value take
value drop
value splitAt
value empty
value singleton
value replicate
value generate
value iterateN
value replicateM
value generateM
value iterateNM
value create
value createT
value unfoldr
value unfoldrN
value unfoldrM
value unfoldrNM
value constructN
value constructrN
value enumFromN
value enumFromStepN
value enumFromTo
value enumFromThenTo
value cons
value snoc
value ++
value concat
value force
value reverse
value modify
value indexed
value map
value imap
value concatMap
value mapM
value imapM
value mapM_
value imapM_
value forM
value forM_
value zipWith
value zipWith3
value zipWith4
value zipWith5
value zipWith6
value izipWith
value izipWith3
value izipWith4
value izipWith5
value izipWith6
value zip
value zip3
value zip4
value zip5
value zip6
value zipWithM
value izipWithM
value zipWithM_
value izipWithM_
value unzip
value unzip3
value unzip4
value unzip5
value unzip6
value filter
value ifilter
value uniq
value mapMaybe
value imapMaybe
value filterM
value takeWhile
value dropWhile
value partition
value unstablePartition
value span
value break
value elem
value notElem
value find
value findIndex
value findIndices
value elemIndex
value elemIndices
value foldl
value foldl'
value foldr
value foldr'
value ifoldl
value ifoldl'
value ifoldr
value ifoldr'
value all
value any
value and
value or
value sum
value product
value foldM
value ifoldM
value foldM'
value ifoldM'
value foldM_
value ifoldM_
value foldM'_
value ifoldM'_
value sequence
value sequence_
value prescanl
value prescanl'
value postscanl
value postscanl'
value scanl
value scanl'
value iscanl
value iscanl'
value prescanr
value prescanr'
value postscanr
value postscanr'
value scanr
value scanr'
value iscanr
value iscanr'
value toList
value fromList
value fromListN
value convert
value freeze
value thaw
value copy

Packagerio-0.1.25.0
Exports136
LanguageHaskell2010
LicenceMIT
SourceBoxed.hs

Boxed vectors

datadata Vector a

Instances27Monad, Functor, MonadFix, MonadFail, Applicative, Foldable, …

Monad VectorDefined in vector-0.13.2.0 · Data.Vector
Functor VectorDefined in vector-0.13.2.0 · Data.Vector
MonadFix VectorDefined in vector-0.13.2.0 · Data.Vector
MonadFail VectorDefined in vector-0.13.2.0 · Data.Vector
Applicative VectorDefined in vector-0.13.2.0 · Data.Vector
Foldable VectorDefined in vector-0.13.2.0 · Data.Vector
Traversable VectorDefined in vector-0.13.2.0 · Data.Vector
Alternative VectorDefined in vector-0.13.2.0 · Data.Vector
MonadPlus VectorDefined in vector-0.13.2.0 · Data.Vector
MonadZip VectorDefined in vector-0.13.2.0 · Data.Vector
Eq1 VectorDefined in vector-0.13.2.0 · Data.Vector
Ord1 VectorDefined in vector-0.13.2.0 · Data.Vector
Read1 VectorDefined in vector-0.13.2.0 · Data.Vector
Show1 VectorDefined in vector-0.13.2.0 · Data.Vector
NFData1 VectorDefined in vector-0.13.2.0 · Data.Vector
Vector Vector aDefined in vector-0.13.2.0 · Data.Vector
IsList (Vector a)Defined in vector-0.13.2.0 · Data.Vector
Eq a => Eq (Vector a)Defined in vector-0.13.2.0 · Data.Vector
Data a => Data (Vector a)Defined in vector-0.13.2.0 · Data.Vector
Ord a => Ord (Vector a)Defined in vector-0.13.2.0 · Data.Vector
Read a => Read (Vector a)Defined in vector-0.13.2.0 · Data.Vector
Show a => Show (Vector a)Defined in vector-0.13.2.0 · Data.Vector
Semigroup (Vector a)Defined in vector-0.13.2.0 · Data.Vector
Monoid (Vector a)Defined in vector-0.13.2.0 · Data.Vector
NFData a => NFData (Vector a)Defined in vector-0.13.2.0 · Data.Vector
type Item (Vector a) = aDefined in vector-0.13.2.0 · Data.Vector
type Mutable Vector = MVectorDefined in vector-0.13.2.0 · Data.Vector

datadata MVector s a

Instances1MVector

MVector MVector aDefined in vector-0.13.2.0 · Data.Vector.Mutable

Accessors

Length information

valuelength :: Vector a -> Int

valuenull :: Vector a -> Bool

Indexing

value(!?) :: Vector a -> Int -> Maybe a

Extracting subvectors

valueslice :: Int -> Int -> Vector a -> Vector a

valuetake :: Int -> Vector a -> Vector a

valuedrop :: Int -> Vector a -> Vector a

valuesplitAt :: Int -> Vector a -> (Vector a, Vector a)

Construction

Initialisation

valueempty :: Vector a

valuesingleton :: a -> Vector a

valuereplicate :: Int -> a -> Vector a

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

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

Monadic initialisation

valuereplicateM :: Monad m => Int -> m a -> m (Vector a)

valuegenerateM :: Monad m => Int -> (Int -> m a) -> m (Vector a)

valueiterateNM :: Monad m => Int -> (a -> m a) -> a -> m (Vector a)

valuecreate :: (forall s. ST s (MVector s a)) -> Vector a

valuecreateT

:: Traversable f
=> forall s. ST s (f (MVector s a))
-> f (Vector a)

Unfolding

valueunfoldr :: (b -> Maybe (a, b)) -> b -> Vector a

valueunfoldrN :: Int -> (b -> Maybe (a, b)) -> b -> Vector a

valueunfoldrM :: Monad m => (b -> m (Maybe (a, b))) -> b -> m (Vector a)

valueunfoldrNM :: Monad m => Int -> (b -> m (Maybe (a, b))) -> b -> m (Vector a)

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

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

Enumeration

valueenumFromN :: Num a => a -> Int -> Vector a

valueenumFromStepN :: Num a => a -> a -> Int -> Vector a

valueenumFromTo :: Enum a => a -> a -> Vector a

valueenumFromThenTo :: Enum a => a -> a -> a -> Vector a

Concatenation

valuecons :: a -> Vector a -> Vector a

valuesnoc :: Vector a -> a -> Vector a

value(++) :: Vector a -> Vector a -> Vector a

valueconcat :: [Vector a] -> Vector a

Restricting memory usage

valueforce :: Vector a -> Vector a

Modifying vectors

Permutations

valuereverse :: Vector a -> Vector a

Safe destructive update

valuemodify :: (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a

Elementwise operations

Indexing

valueindexed :: Vector a -> Vector (Int, a)

Mapping

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

valueimap :: (Int -> a -> b) -> Vector a -> Vector b

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

Monadic mapping

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

valueimapM :: Monad m => (Int -> a -> m b) -> Vector a -> m (Vector b)

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

valueimapM_ :: Monad m => (Int -> a -> m b) -> Vector a -> m ()

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

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

Zipping

valuezipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c

valuezipWith3

:: a -> b -> c -> d
-> Vector a
-> Vector b
-> Vector c
-> Vector d

valuezipWith4

:: a -> b -> c -> d -> e
-> Vector a
-> Vector b
-> Vector c
-> Vector d
-> Vector e

valuezipWith5

:: a -> b -> c -> d -> e -> f
-> Vector a
-> Vector b
-> Vector c
-> Vector d
-> Vector e
-> Vector f

valuezipWith6

:: a -> b -> c -> d -> e -> f -> g
-> Vector a
-> Vector b
-> Vector c
-> Vector d
-> Vector e
-> Vector f
-> Vector g

valueizipWith :: (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c

valueizipWith3

:: Int -> a -> b -> c -> d
-> Vector a
-> Vector b
-> Vector c
-> Vector d

valueizipWith4

:: Int -> a -> b -> c -> d -> e
-> Vector a
-> Vector b
-> Vector c
-> Vector d
-> Vector e

valueizipWith5

:: Int -> a -> b -> c -> d -> e -> f
-> Vector a
-> Vector b
-> Vector c
-> Vector d
-> Vector e
-> Vector f

valueizipWith6

:: Int -> a -> b -> c -> d -> e -> f -> g
-> Vector a
-> Vector b
-> Vector c
-> Vector d
-> Vector e
-> Vector f
-> Vector g

valuezip :: Vector a -> Vector b -> Vector (a, b)

valuezip3 :: Vector a -> Vector b -> Vector c -> Vector (a, b, c)

valuezip4 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)

valuezip5

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

valuezip6

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

Monadic zipping

valuezipWithM

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

valueizipWithM

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

valuezipWithM_ :: Monad m => (a -> b -> m c) -> Vector a -> Vector b -> m ()

valueizipWithM_

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

Unzipping

valueunzip :: Vector (a, b) -> (Vector a, Vector b)

valueunzip3 :: Vector (a, b, c) -> (Vector a, Vector b, Vector c)

valueunzip4 :: Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)

valueunzip5

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

valueunzip6

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

Working with predicates

Filtering

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

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

valueuniq :: Eq a => Vector a -> Vector a

valuemapMaybe :: (a -> Maybe b) -> Vector a -> Vector b

valueimapMaybe :: (Int -> a -> Maybe b) -> Vector a -> Vector b

valuefilterM :: Monad m => (a -> m Bool) -> Vector a -> m (Vector a)

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

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

Partitioning

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

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

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

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

Searching

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

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

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

valuefindIndex :: (a -> Bool) -> Vector a -> Maybe Int

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

valueelemIndex :: Eq a => a -> Vector a -> Maybe Int

valueelemIndices :: Eq a => a -> Vector a -> Vector Int

Folding

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

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

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

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

valueifoldl :: (a -> Int -> b -> a) -> a -> Vector b -> a

valueifoldl' :: (a -> Int -> b -> a) -> a -> Vector b -> a

valueifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b

valueifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b

Specialised folds

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

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

valueand :: Vector Bool -> Bool

valueor :: Vector Bool -> Bool

valuesum :: Num a => Vector a -> a

valueproduct :: Num a => Vector a -> a

Monadic folds

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

valueifoldM :: Monad m => (a -> Int -> b -> m a) -> a -> Vector b -> m a

valuefoldM' :: Monad m => (a -> b -> m a) -> a -> Vector b -> m a

valueifoldM' :: Monad m => (a -> Int -> b -> m a) -> a -> Vector b -> m a

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

valueifoldM_ :: Monad m => (a -> Int -> b -> m a) -> a -> Vector b -> m ()

valuefoldM'_ :: Monad m => (a -> b -> m a) -> a -> Vector b -> m ()

valueifoldM'_ :: Monad m => (a -> Int -> b -> m a) -> a -> Vector b -> m ()

Monadic sequencing

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

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

Prefix sums (scans)

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

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

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

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

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

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

valueiscanl :: (Int -> a -> b -> a) -> a -> Vector b -> Vector a

valueiscanl' :: (Int -> a -> b -> a) -> a -> Vector b -> Vector a

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

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

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

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

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

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

valueiscanr :: (Int -> a -> b -> b) -> b -> Vector a -> Vector b

valueiscanr' :: (Int -> a -> b -> b) -> b -> Vector a -> Vector b

Conversions

Lists

valuetoList :: Vector a -> [a]

valuefromList :: [a] -> Vector a

valuefromListN :: Int -> [a] -> Vector a

Different vector types

valueconvert :: (Vector v a, Vector w a) => v a -> w a

Mutable vectors

valuefreeze :: PrimMonad m => MVector (PrimState m) a -> m (Vector a)

valuethaw :: PrimMonad m => Vector a -> m (MVector (PrimState m) a)

valuecopy :: PrimMonad m => MVector (PrimState m) a -> Vector a -> m ()