RIO.Vector.Boxed · rio-0.1.22.0

Boxed vectors

2 declarations

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

0 declarations

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

0 declarations

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

0 declarations

Permutations

valuereverse :: Vector a -> Vector a

#

Safe destructive update

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

#

Elementwise operations

0 declarations

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

0 declarations

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

8 declarations

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)

16 declarations

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

0 declarations

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

#