rebase-1.21.2: A more progressive alternative to the "base" package
Safe HaskellNone
LanguageHaskell2010

Rebase.Data.Vector.Primitive

Synopsis

Documentation

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

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

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

(!) :: Prim a => Vector a -> Int -> a #

(//) :: Prim a => Vector a -> [(Int, a)] -> Vector a #

accum :: Prim a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a #

unsafeAccum :: Prim a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a #

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

freeze :: (Prim a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a) #

unsafeFreeze :: (Prim a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a) #

thaw :: (Prim a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a) #

unsafeThaw :: (Prim a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a) #

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

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

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

maximumBy :: Prim a => (a -> a -> Ordering) -> Vector a -> a #

minimumBy :: Prim a => (a -> a -> Ordering) -> Vector a -> a #

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

head :: Prim a => Vector a -> a #

group :: (Prim a, Eq a) => Vector a -> [Vector a] #

groupBy :: Prim a => (a -> a -> Bool) -> Vector a -> [Vector a] #

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

foldl1 :: Prim a => (a -> a -> a) -> Vector a -> a #

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

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

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

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

foldMap :: (Monoid m, Prim a) => (a -> m) -> Vector a -> m #

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

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

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

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

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

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

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

empty :: Prim a => Vector a #

uncons :: Prim a => Vector a -> Maybe (a, Vector a) #

unsnoc :: Prim a => Vector a -> Maybe (Vector a, a) #

tail :: Prim a => Vector a -> Vector a #

last :: Prim a => Vector a -> a #

init :: Prim a => Vector a -> Vector a #

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

foldl1' :: Prim a => (a -> a -> a) -> Vector a -> a #

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

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

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

scanl1 :: Prim a => (a -> a -> a) -> Vector a -> Vector a #

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

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

foldr1 :: Prim a => (a -> a -> a) -> Vector a -> a #

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

scanr1 :: Prim a => (a -> a -> a) -> Vector a -> Vector a #

maximum :: (Prim a, Ord a) => Vector a -> a #

minimum :: (Prim a, Ord a) => Vector a -> a #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsafeIndex :: Prim a => Vector a -> Int -> a #

foldMap' :: (Monoid m, Prim a) => (a -> m) -> Vector a -> m #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

foldr1' :: Prim a => (a -> a -> a) -> Vector a -> a #

copy :: (Prim a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m () #

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

create :: Prim a => (forall s. ST s (MVector s a)) -> Vector a #

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

unsafeHead :: Prim a => Vector a -> a #

unsafeTail :: Prim a => Vector a -> Vector a #

unsafeInit :: Prim a => Vector a -> Vector a #

unsafeLast :: Prim a => Vector a -> a #

unsafeTake :: Prim a => Int -> Vector a -> Vector a #

unsafeDrop :: Prim a => Int -> Vector a -> Vector a #

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

findIndexR :: Prim a => (a -> Bool) -> Vector a -> Maybe Int #

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

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

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

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

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

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

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

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

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

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

modify :: Prim a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a #

class Prim a #

Class of types supporting primitive array operations. This includes interfacing with GC-managed memory (functions suffixed with ByteArray#) and interfacing with unmanaged memory (functions suffixed with Addr#). Endianness is platform-dependent.

Instances

Instances details
Prim CBool 
Instance details

Defined in Data.Primitive.Types

Prim CChar 
Instance details

Defined in Data.Primitive.Types

Prim CClock 
Instance details

Defined in Data.Primitive.Types

Prim CDouble 
Instance details

Defined in Data.Primitive.Types

Prim CFloat 
Instance details

Defined in Data.Primitive.Types

Prim CInt 
Instance details

Defined in Data.Primitive.Types

Prim CIntMax 
Instance details

Defined in Data.Primitive.Types

Prim CIntPtr 
Instance details

Defined in Data.Primitive.Types

Prim CLLong 
Instance details

Defined in Data.Primitive.Types

Prim CLong 
Instance details

Defined in Data.Primitive.Types

Prim CPtrdiff 
Instance details

Defined in Data.Primitive.Types

Prim CSChar 
Instance details

Defined in Data.Primitive.Types

Prim CSUSeconds 
Instance details

Defined in Data.Primitive.Types

Prim CShort 
Instance details

Defined in Data.Primitive.Types

Prim CSigAtomic 
Instance details

Defined in Data.Primitive.Types

Prim CSize 
Instance details

Defined in Data.Primitive.Types

Prim CTime 
Instance details

Defined in Data.Primitive.Types

Prim CUChar 
Instance details

Defined in Data.Primitive.Types

Prim CUInt 
Instance details

Defined in Data.Primitive.Types

Prim CUIntMax 
Instance details

Defined in Data.Primitive.Types

Prim CUIntPtr 
Instance details

Defined in Data.Primitive.Types

Prim CULLong 
Instance details

Defined in Data.Primitive.Types

Prim CULong 
Instance details

Defined in Data.Primitive.Types

Prim CUSeconds 
Instance details

Defined in Data.Primitive.Types

Prim CUShort 
Instance details

Defined in Data.Primitive.Types

Prim CWchar 
Instance details

Defined in Data.Primitive.Types

Prim IntPtr

Since: primitive-0.7.1.0

Instance details

Defined in Data.Primitive.Types

Prim WordPtr

Since: primitive-0.7.1.0

Instance details

Defined in Data.Primitive.Types

Prim Int16 
Instance details

Defined in Data.Primitive.Types

Prim Int32 
Instance details

Defined in Data.Primitive.Types

Prim Int64 
Instance details

Defined in Data.Primitive.Types

Prim Int8 
Instance details

Defined in Data.Primitive.Types

Prim Word16 
Instance details

Defined in Data.Primitive.Types

Prim Word32 
Instance details

Defined in Data.Primitive.Types

Prim Word64 
Instance details

Defined in Data.Primitive.Types

Prim Word8 
Instance details

Defined in Data.Primitive.Types

Prim CBlkCnt 
Instance details

Defined in Data.Primitive.Types

Prim CBlkSize 
Instance details

Defined in Data.Primitive.Types

Prim CCc 
Instance details

Defined in Data.Primitive.Types

Prim CClockId 
Instance details

Defined in Data.Primitive.Types

Prim CDev 
Instance details

Defined in Data.Primitive.Types

Prim CFsBlkCnt 
Instance details

Defined in Data.Primitive.Types

Prim CFsFilCnt 
Instance details

Defined in Data.Primitive.Types

Prim CGid 
Instance details

Defined in Data.Primitive.Types

Prim CId 
Instance details

Defined in Data.Primitive.Types

Prim CIno 
Instance details

Defined in Data.Primitive.Types

Prim CKey 
Instance details

Defined in Data.Primitive.Types

Prim CMode 
Instance details

Defined in Data.Primitive.Types

Prim CNlink 
Instance details

Defined in Data.Primitive.Types

Prim COff 
Instance details

Defined in Data.Primitive.Types

Prim CPid 
Instance details

Defined in Data.Primitive.Types

Prim CRLim 
Instance details

Defined in Data.Primitive.Types

Prim CSpeed 
Instance details

Defined in Data.Primitive.Types

Prim CSsize 
Instance details

Defined in Data.Primitive.Types

Prim CTcflag 
Instance details

Defined in Data.Primitive.Types

Prim CTimer 
Instance details

Defined in Data.Primitive.Types

Prim CUid 
Instance details

Defined in Data.Primitive.Types

Prim Fd 
Instance details

Defined in Data.Primitive.Types

Prim Char 
Instance details

Defined in Data.Primitive.Types

Prim Double 
Instance details

Defined in Data.Primitive.Types

Prim Float 
Instance details

Defined in Data.Primitive.Types

Prim Int 
Instance details

Defined in Data.Primitive.Types

Prim Word 
Instance details

Defined in Data.Primitive.Types

Prim a => Prim (Complex a)

Since: primitive-0.9.0.0

Instance details

Defined in Data.Primitive.Types

Prim a => Prim (Identity a)

Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Prim a => Prim (Down a)

Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Prim a => Prim (First a)

Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Prim a => Prim (Last a)

Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Prim a => Prim (Max a)

Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Prim a => Prim (Min a)

Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Prim a => Prim (Dual a)

Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Prim a => Prim (Product a)

Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Prim a => Prim (Sum a)

Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Prim (FunPtr a) 
Instance details

Defined in Data.Primitive.Types

Prim (Ptr a) 
Instance details

Defined in Data.Primitive.Types

Prim (StablePtr a) 
Instance details

Defined in Data.Primitive.Types

Prim a => Prim (Const a b)

Since: primitive-0.6.5.0

Instance details

Defined in Data.Primitive.Types

Methods

sizeOfType# :: Proxy (Const a b) -> Int# #

sizeOf# :: Const a b -> Int# #

alignmentOfType# :: Proxy (Const a b) -> Int# #

alignment# :: Const a b -> Int# #

indexByteArray# :: ByteArray# -> Int# -> Const a b #

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Const a b #) #

writeByteArray# :: MutableByteArray# s -> Int# -> Const a b -> State# s -> State# s #

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Const a b -> State# s -> State# s #

indexOffAddr# :: Addr# -> Int# -> Const a b #

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Const a b #) #

writeOffAddr# :: Addr# -> Int# -> Const a b -> State# s -> State# s #

setOffAddr# :: Addr# -> Int# -> Int# -> Const a b -> State# s -> State# s #

indexM :: (Prim a, Monad m) => Vector a -> Int -> m a #

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

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

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

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

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

mapMaybeM :: (Monad m, Prim a, Prim b) => (a -> m (Maybe b)) -> Vector a -> m (Vector b) #

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

fold1M :: (Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m a #

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

fold1M' :: (Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m a #

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

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

unfoldrExactN :: Prim a => Int -> (b -> (a, b)) -> b -> Vector a #

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

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

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

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

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

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

scanl1' :: Prim a => (a -> a -> a) -> Vector a -> Vector a #

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

data Vector a #

Constructors

Vector !Int !Int !ByteArray 

Instances

Instances details
NFData1 Vector 
Instance details

Defined in Data.Vector.Primitive

Methods

liftRnf :: (a -> ()) -> Vector a -> () #

Prim a => Vector Vector a 
Instance details

Defined in Data.Vector.Primitive

Methods

basicUnsafeFreeze :: Mutable Vector s a -> ST s (Vector a) #

basicUnsafeThaw :: Vector a -> ST s (Mutable Vector s a) #

basicLength :: Vector a -> Int #

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

basicUnsafeIndexM :: Vector a -> Int -> Box a #

basicUnsafeCopy :: Mutable Vector s a -> Vector a -> ST s () #

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

(Data a, Prim a) => Data (Vector a) 
Instance details

Defined in Data.Vector.Primitive

Methods

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) #

toConstr :: Vector a -> Constr #

dataTypeOf :: Vector a -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

Prim a => Monoid (Vector a) 
Instance details

Defined in Data.Vector.Primitive

Methods

mempty :: Vector a #

mappend :: Vector a -> Vector a -> Vector a #

mconcat :: [Vector a] -> Vector a #

Prim a => Semigroup (Vector a) 
Instance details

Defined in Data.Vector.Primitive

Methods

(<>) :: Vector a -> Vector a -> Vector a #

sconcat :: NonEmpty (Vector a) -> Vector a #

stimes :: Integral b => b -> Vector a -> Vector a #

Prim a => IsList (Vector a) 
Instance details

Defined in Data.Vector.Primitive

Associated Types

type Item (Vector a) 
Instance details

Defined in Data.Vector.Primitive

type Item (Vector a) = a

Methods

fromList :: [Item (Vector a)] -> Vector a #

fromListN :: Int -> [Item (Vector a)] -> Vector a #

toList :: Vector a -> [Item (Vector a)] #

(Read a, Prim a) => Read (Vector a) 
Instance details

Defined in Data.Vector.Primitive

(Show a, Prim a) => Show (Vector a) 
Instance details

Defined in Data.Vector.Primitive

Methods

showsPrec :: Int -> Vector a -> ShowS #

show :: Vector a -> String #

showList :: [Vector a] -> ShowS #

NFData (Vector a) 
Instance details

Defined in Data.Vector.Primitive

Methods

rnf :: Vector a -> () #

(Prim a, Eq a) => Eq (Vector a) 
Instance details

Defined in Data.Vector.Primitive

Methods

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

(/=) :: Vector a -> Vector a -> Bool #

(Prim a, Ord a) => Ord (Vector a) 
Instance details

Defined in Data.Vector.Primitive

Methods

compare :: Vector a -> Vector a -> Ordering #

(<) :: Vector a -> Vector a -> Bool #

(<=) :: Vector a -> Vector a -> Bool #

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

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

max :: Vector a -> Vector a -> Vector a #

min :: Vector a -> Vector a -> Vector a #

type Mutable Vector 
Instance details

Defined in Data.Vector.Primitive

type Item (Vector a) 
Instance details

Defined in Data.Vector.Primitive

type Item (Vector a) = a

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

accumulate_ :: (Prim a, Prim b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a #

breakR :: Prim a => (a -> Bool) -> Vector a -> (Vector a, Vector a) #

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

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

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

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

fold1M'_ :: (Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m () #

fold1M_ :: (Monad m, Prim a) => (a -> a -> m a) -> Vector a -> m () #

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

headM :: (Prim a, Monad m) => Vector a -> m a #

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

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

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

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

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

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

imapMaybeM :: (Monad m, Prim a, Prim b) => (Int -> a -> m (Maybe b)) -> Vector a -> m (Vector b) #

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

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

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

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

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

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

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

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

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

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

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

lastM :: (Prim a, Monad m) => Vector a -> m a #

maxIndex :: (Prim a, Ord a) => Vector a -> Int #

maxIndexBy :: Prim a => (a -> a -> Ordering) -> Vector a -> Int #

maximumOn :: (Ord b, Prim a) => (a -> b) -> Vector a -> a #

minIndex :: (Prim a, Ord a) => Vector a -> Int #

minIndexBy :: Prim a => (a -> a -> Ordering) -> Vector a -> Int #

minimumOn :: (Ord b, Prim a) => (a -> b) -> Vector a -> a #

partitionWith :: (Prim a, Prim b, Prim c) => (a -> Either b c) -> Vector a -> (Vector b, Vector c) #

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

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

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

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

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

scanr1' :: Prim a => (a -> a -> a) -> Vector a -> Vector a #

spanR :: Prim a => (a -> Bool) -> Vector a -> (Vector a, Vector a) #

unsafeAccumulate_ :: (Prim a, Prim b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a #

unsafeCopy :: (Prim a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m () #

unsafeHeadM :: (Prim a, Monad m) => Vector a -> m a #

unsafeIndexM :: (Prim a, Monad m) => Vector a -> Int -> m a #

unsafeLastM :: (Prim a, Monad m) => Vector a -> m a #

unsafeSlice :: Prim a => Int -> Int -> Vector a -> Vector a #

unsafeUpd :: Prim a => Vector a -> [(Int, a)] -> Vector a #

unsafeUpdate_ :: Prim a => Vector a -> Vector Int -> Vector a -> Vector a #

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

update_ :: Prim a => Vector a -> Vector Int -> Vector a -> Vector a #

data MVector s a #

Constructors

MVector !Int !Int !(MutableByteArray s) 

Instances

Instances details
Prim a => MVector MVector a 
Instance details

Defined in Data.Vector.Primitive.Mutable

Methods

basicLength :: MVector s a -> Int #

basicUnsafeSlice :: Int -> Int -> MVector s a -> MVector s a #

basicOverlaps :: MVector s a -> MVector s a -> Bool #

basicUnsafeNew :: Int -> ST s (MVector s a) #

basicInitialize :: MVector s a -> ST s () #

basicUnsafeReplicate :: Int -> a -> ST s (MVector s a) #

basicUnsafeRead :: MVector s a -> Int -> ST s a #

basicUnsafeWrite :: MVector s a -> Int -> a -> ST s () #

basicClear :: MVector s a -> ST s () #

basicSet :: MVector s a -> a -> ST s () #

basicUnsafeCopy :: MVector s a -> MVector s a -> ST s () #

basicUnsafeMove :: MVector s a -> MVector s a -> ST s () #

basicUnsafeGrow :: MVector s a -> Int -> ST s (MVector s a) #

NFData1 (MVector s) 
Instance details

Defined in Data.Vector.Primitive.Mutable

Methods

liftRnf :: (a -> ()) -> MVector s a -> () #

NFData (MVector s a) 
Instance details

Defined in Data.Vector.Primitive.Mutable

Methods

rnf :: MVector s a -> () #