Rebase.Data.Vector · rebase-1.21.2

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

#

datadata Vector a

#

Instances44Monad, 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
Hashable1 VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
Alt VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
Apply VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
Bind VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
Extend VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
Plus VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
Adjustable VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
FoldableWithKey VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
Indexable VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
Keyed VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
Lookup VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
TraversableWithKey VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
Zip VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
ZipWithKey VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
Pointed VectorDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
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
Hashable a => Hashable (Vector a)Defined in vector-instances-3.4.2 · Data.Vector.Instances · orphan
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
type Key Vector = IntDefined in vector-instances-3.4.2 · Data.Vector.Instances · orphan

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

#

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

#

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

#

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

#

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

#

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

#

valuetoList :: Vector a -> [a]

#

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

#

valueand :: Vector Bool -> Bool

#

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

#

valueconcat :: [Vector a] -> Vector a

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

valueor :: Vector Bool -> Bool

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

valueempty :: Vector a

#

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

#

valuenull :: Vector a -> Bool

#

valuelength :: Vector a -> Int

#

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

#

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

#

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

#

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

#

valueinit :: Vector a -> Vector a

#

valuereplicate :: Int -> a -> Vector a

#

valuereverse :: Vector a -> Vector a

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

valueunsafeIndex :: Vector a -> Int -> a

#

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

#

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

#

valuehead :: Vector a -> a

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

valuesingleton :: a -> Vector a

#

valueunsafeHead :: Vector a -> a

#

valueunsafeTail :: Vector a -> Vector a

#

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

#

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

#

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

#

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

#

valuelast :: Vector a -> a

#

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

#

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

#

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

#

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

#

valuetail :: Vector a -> Vector a

#

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

#

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

#

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

#

valuefromList :: [a] -> Vector a

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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)

#

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)

#

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

#

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

#

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

#

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

#

valuezipWith3

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

#

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

#

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

#

valuefromArray :: Array a -> Vector a

#

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

#

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

#

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

#

valuegenerateM :: Monad m => Int -> (Int -> m a) -> m (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

#

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

#

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

#

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

#

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

#

valueunsafeInit :: Vector a -> Vector a

#

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

#

datadata MVector s a

#

Instances1MVector

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

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
-> Vector b
-> Vector a

#

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

#

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

#

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

#

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

#

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

#

valuecreateT

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

#

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

#

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

#

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

#

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

#

valueforce :: Vector a -> Vector a

#

valuefreeze :: PrimMonad m => MVector (PrimState m) a -> m (Vector 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 ()

#

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

#

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

#

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

#

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

#

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

#

valueimapMaybeM

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

valueminimumOn :: Ord b => (a -> b) -> Vector a -> 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

#

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

#

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

#

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

#

valuespanR :: (a -> Bool) -> Vector a -> (Vector a, 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)

#

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
-> Vector b
-> Vector a

#

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

#

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

#

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

#

valueunsafeLast :: Vector a -> a

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

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

#

valuetoArray :: Vector a -> Array a

#

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

#

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

#