Modulevector-0.13.2.0

Data.Vector.Strict

Synopsis

value convert
value !
value !?
value ++
value //
value accum
value accumulate
value accumulate_
value all
value and
value any
value backpermute
value break
value breakR
value catMaybes
value cmpBy
value concat
value concatMap
value cons
value constructN
value constructrN
value copy
value create
value createT
value drop
value dropWhile
value elem
value elemIndex
value elemIndices
value empty
value enumFromN
value enumFromStepN
value enumFromThenTo
value enumFromTo
value eqBy
value filter
value filterM
value find
value findIndex
value findIndexR
value findIndices
value fold1M
value fold1M'
value fold1M'_
value fold1M_
value foldM
value foldM'
value foldM'_
value foldM_
value foldMap
value foldMap'
value foldl
value foldl'
value foldl1
value foldl1'
value foldr
value foldr'
value foldr1
value foldr1'
value forM
value forM_
value force
value freeze
value fromArray
value fromLazy
value fromList
value fromListN
value generate
value generateM
value group
value groupBy
value head
value headM
value ifilter
value ifoldM
value ifoldM'
value ifoldM'_
value ifoldM_
value ifoldl
value ifoldl'
value ifoldr
value ifoldr'
value iforM
value iforM_
value imap
value imapM
value imapM_
value imapMaybe
value imapMaybeM
value indexM
value indexed
value init
value iscanl
value iscanl'
value iscanr
value iscanr'
value iterateN
value iterateNM
value izipWith
value izipWith3
value izipWith4
value izipWith5
value izipWith6
value izipWithM
value izipWithM_
value last
value lastM
value length
value map
value mapM
value mapM_
value mapMaybe
value mapMaybeM
value maxIndex
value maxIndexBy
value maximum
value maximumBy
value maximumOn
value minIndex
value minIndexBy
value minimum
value minimumBy
value minimumOn
value modify
value notElem
value null
value or
value partition
value partitionWith
value postscanl
value postscanl'
value postscanr
value postscanr'
value prescanl
value prescanl'
value prescanr
value prescanr'
value product
value replicate
value replicateM
value reverse
value scanl
value scanl'
value scanl1
value scanl1'
value scanr
value scanr'
value scanr1
value scanr1'
value sequence
value sequence_
value singleton
value slice
value snoc
value span
value spanR
value splitAt
value sum
value tail
value take
value takeWhile
value thaw
value toArray
value toArraySlice
value toLazy
value toList
value uncons
value unfoldr
value unfoldrExactN
value unfoldrExactNM
value unfoldrM
value unfoldrN
value unfoldrNM
value uniq
value unsafeAccum
value unsafeAccumulate
value unsafeAccumulate_
value unsafeBackpermute
value unsafeCopy
value unsafeDrop
value unsafeFreeze
value unsafeFromArraySlice
value unsafeHead
value unsafeHeadM
value unsafeIndex
value unsafeIndexM
value unsafeInit
value unsafeLast
value unsafeLastM
value unsafeSlice
value unsafeTail
value unsafeTake
value unsafeThaw
value unsafeUpd
value unsafeUpdate
value unsafeUpdate_
value unsnoc
value unstablePartition
value unzip
value unzip3
value unzip4
value unzip5
value unzip6
value update
value update_
value zip
value zip3
value zip4
value zip5
value zip6
value zipWith
value zipWith3
value zipWith4
value zipWith5
value zipWith6
value zipWithM
value zipWithM_
newtype Vector
newtype MVector

Packagevector-0.13.2.0
Exports219
LicenceBSD-3-Clause

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

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

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

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

value(//) :: Vector a -> [(Int, a)] -> Vector a

valueaccum :: (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a

valueaccumulate :: (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a

valueaccumulate_

:: a -> b -> a
-> Vector a
-> Vector Int
-> Vector b
-> Vector a

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

valueand :: Vector Bool -> Bool

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

valuebackpermute :: Vector a -> Vector Int -> Vector a

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

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

valuecatMaybes :: Vector (Maybe a) -> Vector a

valuecmpBy :: (a -> b -> Ordering) -> Vector a -> Vector b -> Ordering

valueconcat :: [Vector a] -> Vector a

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

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

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

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

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

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

valuecreateT

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

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

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

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

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

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

valueempty :: Vector a

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

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

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

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

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

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

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

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

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

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

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

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

valuefold1M' :: Monad m => (a -> a -> m a) -> Vector a -> m a

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

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

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

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

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

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

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

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

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

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

valuefoldl1 :: (a -> a -> a) -> Vector a -> a

valuefoldl1' :: (a -> a -> a) -> Vector a -> a

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

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

valuefoldr1 :: (a -> a -> a) -> Vector a -> a

valuefoldr1' :: (a -> a -> a) -> Vector a -> a

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

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

valueforce :: Vector a -> Vector a

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

valuefromArray :: Array a -> Vector a

valuefromLazy :: Vector a -> Vector a

valuefromList :: [a] -> Vector a

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

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

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

valuegroup :: Eq a => Vector a -> [Vector a]

valuegroupBy :: (a -> a -> Bool) -> Vector a -> [Vector a]

valuehead :: Vector a -> a

valueheadM :: Monad m => Vector a -> m a

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

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

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

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

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

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

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

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

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

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

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

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

valueimapMaybeM

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

valueindexM :: Monad m => Vector a -> Int -> m a

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

valueinit :: Vector a -> Vector a

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

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

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

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

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

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

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

valueizipWithM

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

valueizipWithM_

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

valuelast :: Vector a -> a

valuelastM :: Monad m => Vector a -> m a

valuelength :: Vector a -> Int

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

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

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

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

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

valuemaxIndex :: Ord a => Vector a -> Int

valuemaxIndexBy :: (a -> a -> Ordering) -> Vector a -> Int

valuemaximum :: Ord a => Vector a -> a

valuemaximumBy :: (a -> a -> Ordering) -> Vector a -> a

valuemaximumOn :: Ord b => (a -> b) -> Vector a -> a

valueminIndex :: Ord a => Vector a -> Int

valueminIndexBy :: (a -> a -> Ordering) -> Vector a -> Int

valueminimum :: Ord a => Vector a -> a

valueminimumBy :: (a -> a -> Ordering) -> Vector a -> a

valueminimumOn :: Ord b => (a -> b) -> Vector a -> a

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

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

valuenull :: Vector a -> Bool

valueor :: Vector Bool -> Bool

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

valuepartitionWith :: (a -> Either b c) -> Vector a -> (Vector b, Vector c)

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

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

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

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

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

valueprescanl' :: (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

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

valuereplicate :: Int -> a -> Vector a

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

valuereverse :: Vector a -> Vector a

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

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

valuescanl1 :: (a -> a -> a) -> Vector a -> Vector a

valuescanl1' :: (a -> a -> a) -> Vector a -> Vector a

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

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

valuescanr1 :: (a -> a -> a) -> Vector a -> Vector a

valuescanr1' :: (a -> a -> a) -> Vector a -> Vector a

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

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

valuesingleton :: a -> Vector a

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

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

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

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

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

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

valuetail :: Vector a -> Vector a

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

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

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

valuetoArray :: Vector a -> Array a

valuetoArraySlice :: Vector a -> (Array a, Int, Int)

valuetoLazy :: Vector a -> Vector a

valuetoList :: Vector a -> [a]

valueuncons :: Vector a -> Maybe (a, Vector a)

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

valueunfoldrExactN :: Int -> (b -> (a, b)) -> b -> Vector a

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

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

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

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

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

valueunsafeAccum :: (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a

valueunsafeAccumulate :: (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a

valueunsafeAccumulate_

:: a -> b -> a
-> Vector a
-> Vector Int
-> Vector b
-> Vector a

valueunsafeBackpermute :: Vector a -> Vector Int -> Vector a

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

valueunsafeDrop :: Int -> Vector a -> Vector a

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

valueunsafeFromArraySlice :: Array a -> Int -> Int -> Vector a

valueunsafeHead :: Vector a -> a

valueunsafeHeadM :: Monad m => Vector a -> m a

valueunsafeIndex :: Vector a -> Int -> a

valueunsafeIndexM :: Monad m => Vector a -> Int -> m a

valueunsafeInit :: Vector a -> Vector a

valueunsafeLast :: Vector a -> a

valueunsafeLastM :: Monad m => Vector a -> m a

valueunsafeSlice :: Int -> Int -> Vector a -> Vector a

valueunsafeTail :: Vector a -> Vector a

valueunsafeTake :: Int -> Vector a -> Vector a

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

valueunsafeUpd :: Vector a -> [(Int, a)] -> Vector a

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

valueunsafeUpdate_ :: Vector a -> Vector Int -> Vector a -> Vector a

valueunsnoc :: Vector a -> Maybe (Vector a, a)

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

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)

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

valueupdate_ :: Vector a -> Vector Int -> Vector a -> Vector a

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)

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

valuezipWithM

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

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

newtypenewtype Vector a

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

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

newtypenewtype MVector s a

Instances1MVector

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