Safe Haskell | None |
---|---|
Language | Haskell2010 |
Rebase.Data.Vector.Primitive
Synopsis
- (++) :: 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
- 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 = Vector !Int !Int !ByteArray
- 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
- backpermute :: Prim a => Vector a -> Vector Int -> 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
- unsafeBackpermute :: Prim a => Vector a -> Vector Int -> 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 = MVector !Int !Int !(MutableByteArray s)
- unsafeCast :: (HasCallStack, Prim a, Prim b) => Vector a -> Vector b
- unsafeCoerceVector :: Coercible a b => Vector a -> Vector b
Documentation
enumFromTo :: (Prim a, Enum a) => a -> a -> Vector a #
enumFromThenTo :: (Prim a, Enum a) => a -> a -> a -> Vector a #
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 #
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 #
zipWithM :: (Monad m, Prim a, Prim b, Prim c) => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c) #
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 #
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.
Minimal complete definition
(sizeOfType# | sizeOf#), (alignmentOfType# | alignment#), indexByteArray#, readByteArray#, writeByteArray#, indexOffAddr#, readOffAddr#, writeOffAddr#
Instances
unfoldrExactN :: Prim a => Int -> (b -> (a, b)) -> b -> Vector a #
Instances
NFData1 Vector | |
Defined in Data.Vector.Primitive | |
Prim a => Vector Vector a | |
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 () # | |
(Data a, Prim a) => Data (Vector a) | |
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) | |
Prim a => Semigroup (Vector a) | |
Prim a => IsList (Vector a) | |
(Read a, Prim a) => Read (Vector a) | |
(Show a, Prim a) => Show (Vector a) | |
NFData (Vector a) | |
Defined in Data.Vector.Primitive | |
(Prim a, Eq a) => Eq (Vector a) | |
(Prim a, Ord a) => Ord (Vector a) | |
Defined in Data.Vector.Primitive | |
type Mutable Vector | |
Defined in Data.Vector.Primitive | |
type Item (Vector a) | |
Defined in Data.Vector.Primitive |
accumulate_ :: (Prim a, Prim b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a #
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) #
partitionWith :: (Prim a, Prim b, Prim c) => (a -> Either b c) -> Vector a -> (Vector b, Vector c) #
unsafeAccumulate_ :: (Prim a, Prim b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a #
unsafeHeadM :: (Prim a, Monad m) => Vector a -> m a #
unsafeLastM :: (Prim a, Monad m) => Vector a -> m a #
Constructors
MVector !Int !Int !(MutableByteArray s) |
Instances
Prim a => MVector MVector a | |
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) | |
Defined in Data.Vector.Primitive.Mutable | |
NFData (MVector s a) | |
Defined in Data.Vector.Primitive.Mutable |
unsafeCast :: (HasCallStack, Prim a, Prim b) => Vector a -> Vector b #
unsafeCoerceVector :: Coercible a b => Vector a -> Vector b #