Copyright	(c) Roman Leshchinskiy 2009-2010
License	BSD-style
Maintainer	Roman Leshchinskiy <rl@cse.unsw.edu.au>
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Data.Vector.Unboxed

Contents

Unboxed vectors
Accessors
Construction
Modifying vectors
Elementwise operations
Working with predicates
Folding
- Specialised folds
- Monadic folds
Prefix sums (scans)
- Comparisons
Conversions
Orphan instances

Description

Adaptive unboxed vectors. The implementation is based on type families and picks an efficient, specialised representation for every element type. In particular, unboxed vectors of pairs are represented as pairs of unboxed vectors.

Implementing unboxed vectors for new data types can be very easy. Here is how the library does this for Complex by simply wrapping vectors of pairs.

newtype instance MVector s (Complex a) = MV_Complex (MVector s (a,a))
newtype instance Vector    (Complex a) = V_Complex  (Vector    (a,a))

instance (RealFloat a, Unbox a) => MVector MVector (Complex a) where
  {-# INLINE basicLength #-}
  basicLength (MV_Complex v) = basicLength v
  ...

instance (RealFloat a, Unbox a) => Data.Vector.Generic.Vector Vector (Complex a) where
  {-# INLINE basicLength #-}
  basicLength (V_Complex v) = Data.Vector.Generic.basicLength v
  ...

instance (RealFloat a, Unbox a) => Unbox (Complex a)

Synopsis

data family Vector a
data family MVector s a
class ( Vector Vector a, MVector MVector a) => Unbox a
length :: Unbox a => Vector a -> Int
null :: Unbox a => Vector a -> Bool
(!) :: Unbox a => Vector a -> Int -> a
(!?) :: Unbox a => Vector a -> Int -> Maybe a
head :: Unbox a => Vector a -> a
last :: Unbox a => Vector a -> a
unsafeIndex :: Unbox a => Vector a -> Int -> a
unsafeHead :: Unbox a => Vector a -> a
unsafeLast :: Unbox a => Vector a -> a
indexM :: ( Unbox a, Monad m) => Vector a -> Int -> m a
headM :: ( Unbox a, Monad m) => Vector a -> m a
lastM :: ( Unbox a, Monad m) => Vector a -> m a
unsafeIndexM :: ( Unbox a, Monad m) => Vector a -> Int -> m a
unsafeHeadM :: ( Unbox a, Monad m) => Vector a -> m a
unsafeLastM :: ( Unbox a, Monad m) => Vector a -> m a
slice :: Unbox a => Int -> Int -> Vector a -> Vector a
init :: Unbox a => Vector a -> Vector a
tail :: Unbox a => Vector a -> Vector a
take :: Unbox a => Int -> Vector a -> Vector a
drop :: Unbox a => Int -> Vector a -> Vector a
splitAt :: Unbox a => Int -> Vector a -> ( Vector a, Vector a)
uncons :: Unbox a => Vector a -> Maybe (a, Vector a)
unsnoc :: Unbox a => Vector a -> Maybe ( Vector a, a)
unsafeSlice :: Unbox a => Int -> Int -> Vector a -> Vector a
unsafeInit :: Unbox a => Vector a -> Vector a
unsafeTail :: Unbox a => Vector a -> Vector a
unsafeTake :: Unbox a => Int -> Vector a -> Vector a
unsafeDrop :: Unbox a => Int -> Vector a -> Vector a
empty :: Unbox a => Vector a
singleton :: Unbox a => a -> Vector a
replicate :: Unbox a => Int -> a -> Vector a
generate :: Unbox a => Int -> ( Int -> a) -> Vector a
iterateN :: Unbox a => Int -> (a -> a) -> a -> Vector a
replicateM :: ( Monad m, Unbox a) => Int -> m a -> m ( Vector a)
generateM :: ( Monad m, Unbox a) => Int -> ( Int -> m a) -> m ( Vector a)
iterateNM :: ( Monad m, Unbox a) => Int -> (a -> m a) -> a -> m ( Vector a)
create :: Unbox a => ( forall s. ST s ( MVector s a)) -> Vector a
createT :: ( Traversable f, Unbox a) => ( forall s. ST s (f ( MVector s a))) -> f ( Vector a)
unfoldr :: Unbox a => (b -> Maybe (a, b)) -> b -> Vector a
unfoldrN :: Unbox a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
unfoldrExactN :: Unbox a => Int -> (b -> (a, b)) -> b -> Vector a
unfoldrM :: ( Monad m, Unbox a) => (b -> m ( Maybe (a, b))) -> b -> m ( Vector a)
unfoldrNM :: ( Monad m, Unbox a) => Int -> (b -> m ( Maybe (a, b))) -> b -> m ( Vector a)
unfoldrExactNM :: ( Monad m, Unbox a) => Int -> (b -> m (a, b)) -> b -> m ( Vector a)
constructN :: Unbox a => Int -> ( Vector a -> a) -> Vector a
constructrN :: Unbox a => Int -> ( Vector a -> a) -> Vector a
enumFromN :: ( Unbox a, Num a) => a -> Int -> Vector a
enumFromStepN :: ( Unbox a, Num a) => a -> a -> Int -> Vector a
enumFromTo :: ( Unbox a, Enum a) => a -> a -> Vector a
enumFromThenTo :: ( Unbox a, Enum a) => a -> a -> a -> Vector a
cons :: Unbox a => a -> Vector a -> Vector a
snoc :: Unbox a => Vector a -> a -> Vector a
(++) :: Unbox a => Vector a -> Vector a -> Vector a
concat :: Unbox a => [ Vector a] -> Vector a
force :: Unbox a => Vector a -> Vector a
(//) :: Unbox a => Vector a -> [( Int , a)] -> Vector a
update :: Unbox a => Vector a -> Vector ( Int , a) -> Vector a
update_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a
unsafeUpd :: Unbox a => Vector a -> [( Int , a)] -> Vector a
unsafeUpdate :: Unbox a => Vector a -> Vector ( Int , a) -> Vector a
unsafeUpdate_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a
accum :: Unbox a => (a -> b -> a) -> Vector a -> [( Int , b)] -> Vector a
accumulate :: ( Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector ( Int , b) -> Vector a
accumulate_ :: ( Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
unsafeAccum :: Unbox a => (a -> b -> a) -> Vector a -> [( Int , b)] -> Vector a
unsafeAccumulate :: ( Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector ( Int , b) -> Vector a
unsafeAccumulate_ :: ( Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
reverse :: Unbox a => Vector a -> Vector a
backpermute :: Unbox a => Vector a -> Vector Int -> Vector a
unsafeBackpermute :: Unbox a => Vector a -> Vector Int -> Vector a
modify :: Unbox a => ( forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
indexed :: Unbox a => Vector a -> Vector ( Int , a)
map :: ( Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
imap :: ( Unbox a, Unbox b) => ( Int -> a -> b) -> Vector a -> Vector b
concatMap :: ( Unbox a, Unbox b) => (a -> Vector b) -> Vector a -> Vector b
mapM :: ( Monad m, Unbox a, Unbox b) => (a -> m b) -> Vector a -> m ( Vector b)
imapM :: ( Monad m, Unbox a, Unbox b) => ( Int -> a -> m b) -> Vector a -> m ( Vector b)
mapM_ :: ( Monad m, Unbox a) => (a -> m b) -> Vector a -> m ()
imapM_ :: ( Monad m, Unbox a) => ( Int -> a -> m b) -> Vector a -> m ()
forM :: ( Monad m, Unbox a, Unbox b) => Vector a -> (a -> m b) -> m ( Vector b)
forM_ :: ( Monad m, Unbox a) => Vector a -> (a -> m b) -> m ()
iforM :: ( Monad m, Unbox a, Unbox b) => Vector a -> ( Int -> a -> m b) -> m ( Vector b)
iforM_ :: ( Monad m, Unbox a) => Vector a -> ( Int -> a -> m b) -> m ()
zipWith :: ( Unbox a, Unbox b, Unbox c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c
zipWith3 :: ( Unbox a, Unbox b, Unbox c, Unbox d) => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
zipWith4 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
zipWith5 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => (a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
zipWith6 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => (a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
izipWith :: ( Unbox a, Unbox b, Unbox c) => ( Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
izipWith3 :: ( Unbox a, Unbox b, Unbox c, Unbox d) => ( Int -> a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
izipWith4 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => ( Int -> a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
izipWith5 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => ( Int -> a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
izipWith6 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => ( Int -> a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
zip :: ( Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)
zip3 :: ( Unbox a, Unbox b, Unbox c) => Vector a -> Vector b -> Vector c -> Vector (a, b, c)
zip4 :: ( Unbox a, Unbox b, Unbox c, Unbox d) => Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)
zip5 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)
zip6 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector (a, b, c, d, e, f)
zipWithM :: ( Monad m, Unbox a, Unbox b, Unbox c) => (a -> b -> m c) -> Vector a -> Vector b -> m ( Vector c)
izipWithM :: ( Monad m, Unbox a, Unbox b, Unbox c) => ( Int -> a -> b -> m c) -> Vector a -> Vector b -> m ( Vector c)
zipWithM_ :: ( Monad m, Unbox a, Unbox b) => (a -> b -> m c) -> Vector a -> Vector b -> m ()
izipWithM_ :: ( Monad m, Unbox a, Unbox b) => ( Int -> a -> b -> m c) -> Vector a -> Vector b -> m ()
unzip :: ( Unbox a, Unbox b) => Vector (a, b) -> ( Vector a, Vector b)
unzip3 :: ( Unbox a, Unbox b, Unbox c) => Vector (a, b, c) -> ( Vector a, Vector b, Vector c)
unzip4 :: ( Unbox a, Unbox b, Unbox c, Unbox d) => Vector (a, b, c, d) -> ( Vector a, Vector b, Vector c, Vector d)
unzip5 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector (a, b, c, d, e) -> ( Vector a, Vector b, Vector c, Vector d, Vector e)
unzip6 :: ( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector (a, b, c, d, e, f) -> ( Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
filter :: Unbox a => (a -> Bool ) -> Vector a -> Vector a
ifilter :: Unbox a => ( Int -> a -> Bool ) -> Vector a -> Vector a
filterM :: ( Monad m, Unbox a) => (a -> m Bool ) -> Vector a -> m ( Vector a)
uniq :: ( Unbox a, Eq a) => Vector a -> Vector a
mapMaybe :: ( Unbox a, Unbox b) => (a -> Maybe b) -> Vector a -> Vector b
imapMaybe :: ( Unbox a, Unbox b) => ( Int -> a -> Maybe b) -> Vector a -> Vector b
mapMaybeM :: ( Monad m, Unbox a, Unbox b) => (a -> m ( Maybe b)) -> Vector a -> m ( Vector b)
imapMaybeM :: ( Monad m, Unbox a, Unbox b) => ( Int -> a -> m ( Maybe b)) -> Vector a -> m ( Vector b)
takeWhile :: Unbox a => (a -> Bool ) -> Vector a -> Vector a
dropWhile :: Unbox a => (a -> Bool ) -> Vector a -> Vector a
partition :: Unbox a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
unstablePartition :: Unbox a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
partitionWith :: ( Unbox a, Unbox b, Unbox c) => (a -> Either b c) -> Vector a -> ( Vector b, Vector c)
span :: Unbox a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
break :: Unbox a => (a -> Bool ) -> Vector a -> ( Vector a, Vector a)
elem :: ( Unbox a, Eq a) => a -> Vector a -> Bool
notElem :: ( Unbox a, Eq a) => a -> Vector a -> Bool
find :: Unbox a => (a -> Bool ) -> Vector a -> Maybe a
findIndex :: Unbox a => (a -> Bool ) -> Vector a -> Maybe Int
findIndices :: Unbox a => (a -> Bool ) -> Vector a -> Vector Int
elemIndex :: ( Unbox a, Eq a) => a -> Vector a -> Maybe Int
elemIndices :: ( Unbox a, Eq a) => a -> Vector a -> Vector Int
foldl :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
foldl1 :: Unbox a => (a -> a -> a) -> Vector a -> a
foldl' :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
foldl1' :: Unbox a => (a -> a -> a) -> Vector a -> a
foldr :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
foldr1 :: Unbox a => (a -> a -> a) -> Vector a -> a
foldr' :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
foldr1' :: Unbox a => (a -> a -> a) -> Vector a -> a
ifoldl :: Unbox b => (a -> Int -> b -> a) -> a -> Vector b -> a
ifoldl' :: Unbox b => (a -> Int -> b -> a) -> a -> Vector b -> a
ifoldr :: Unbox a => ( Int -> a -> b -> b) -> b -> Vector a -> b
ifoldr' :: Unbox a => ( Int -> a -> b -> b) -> b -> Vector a -> b
foldMap :: ( Monoid m, Unbox a) => (a -> m) -> Vector a -> m
foldMap' :: ( Monoid m, Unbox a) => (a -> m) -> Vector a -> m
all :: Unbox a => (a -> Bool ) -> Vector a -> Bool
any :: Unbox a => (a -> Bool ) -> Vector a -> Bool
and :: Vector Bool -> Bool
or :: Vector Bool -> Bool
sum :: ( Unbox a, Num a) => Vector a -> a
product :: ( Unbox a, Num a) => Vector a -> a
maximum :: ( Unbox a, Ord a) => Vector a -> a
maximumBy :: Unbox a => (a -> a -> Ordering ) -> Vector a -> a
minimum :: ( Unbox a, Ord a) => Vector a -> a
minimumBy :: Unbox a => (a -> a -> Ordering ) -> Vector a -> a
minIndex :: ( Unbox a, Ord a) => Vector a -> Int
minIndexBy :: Unbox a => (a -> a -> Ordering ) -> Vector a -> Int
maxIndex :: ( Unbox a, Ord a) => Vector a -> Int
maxIndexBy :: Unbox a => (a -> a -> Ordering ) -> Vector a -> Int
foldM :: ( Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
ifoldM :: ( Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
foldM' :: ( Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
ifoldM' :: ( Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
fold1M :: ( Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m a
fold1M' :: ( Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m a
foldM_ :: ( Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m ()
ifoldM_ :: ( Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
foldM'_ :: ( Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m ()
ifoldM'_ :: ( Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
fold1M_ :: ( Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m ()
fold1M'_ :: ( Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m ()
prescanl :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
prescanl' :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
postscanl :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
postscanl' :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
scanl :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
scanl' :: ( Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
scanl1 :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
scanl1' :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
iscanl :: ( Unbox a, Unbox b) => ( Int -> a -> b -> a) -> a -> Vector b -> Vector a
iscanl' :: ( Unbox a, Unbox b) => ( Int -> a -> b -> a) -> a -> Vector b -> Vector a
prescanr :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
prescanr' :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
postscanr :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
postscanr' :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanr :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanr' :: ( Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanr1 :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
scanr1' :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
iscanr :: ( Unbox a, Unbox b) => ( Int -> a -> b -> b) -> b -> Vector a -> Vector b
iscanr' :: ( Unbox a, Unbox b) => ( Int -> a -> b -> b) -> b -> Vector a -> Vector b
eqBy :: ( Unbox a, Unbox b) => (a -> b -> Bool ) -> Vector a -> Vector b -> Bool
cmpBy :: ( Unbox a, Unbox b) => (a -> b -> Ordering ) -> Vector a -> Vector b -> Ordering
toList :: Unbox a => Vector a -> [a]
fromList :: Unbox a => [a] -> Vector a
fromListN :: Unbox a => Int -> [a] -> Vector a
convert :: ( Vector v a, Vector w a) => v a -> w a
freeze :: ( Unbox a, PrimMonad m) => MVector ( PrimState m) a -> m ( Vector a)
thaw :: ( Unbox a, PrimMonad m) => Vector a -> m ( MVector ( PrimState m) a)
copy :: ( Unbox a, PrimMonad m) => MVector ( PrimState m) a -> Vector a -> m ()
unsafeFreeze :: ( Unbox a, PrimMonad m) => MVector ( PrimState m) a -> m ( Vector a)
unsafeThaw :: ( Unbox a, PrimMonad m) => Vector a -> m ( MVector ( PrimState m) a)
unsafeCopy :: ( Unbox a, PrimMonad m) => MVector ( PrimState m) a -> Vector a -> m ()

Unboxed vectors

data family Vector a Source #

Instances

Instances details

NFData1 Vector Source #	Since: 0.12.1.0
Instance details Defined in Data.Vector.Unboxed.Base Methods liftRnf :: (a -> ()) -> Vector a -> () Source #
Vector Vector Bool Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Bool -> m ( Vector Bool ) Source # basicUnsafeThaw :: PrimMonad m => Vector Bool -> m ( Mutable Vector ( PrimState m) Bool ) Source # basicLength :: Vector Bool -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool Source # basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Bool -> Vector Bool -> m () Source # elemseq :: Vector Bool -> Bool -> b -> b Source #
Vector Vector Char Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Char -> m ( Vector Char ) Source # basicUnsafeThaw :: PrimMonad m => Vector Char -> m ( Mutable Vector ( PrimState m) Char ) Source # basicLength :: Vector Char -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char Source # basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Char -> Vector Char -> m () Source # elemseq :: Vector Char -> Char -> b -> b Source #
Vector Vector Double Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Double -> m ( Vector Double ) Source # basicUnsafeThaw :: PrimMonad m => Vector Double -> m ( Mutable Vector ( PrimState m) Double ) Source # basicLength :: Vector Double -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double Source # basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Double -> Vector Double -> m () Source # elemseq :: Vector Double -> Double -> b -> b Source #
Vector Vector Float Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Float -> m ( Vector Float ) Source # basicUnsafeThaw :: PrimMonad m => Vector Float -> m ( Mutable Vector ( PrimState m) Float ) Source # basicLength :: Vector Float -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float Source # basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Float -> Vector Float -> m () Source # elemseq :: Vector Float -> Float -> b -> b Source #
Vector Vector Int Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Int -> m ( Vector Int ) Source # basicUnsafeThaw :: PrimMonad m => Vector Int -> m ( Mutable Vector ( PrimState m) Int ) Source # basicLength :: Vector Int -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int Source # basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Int -> Vector Int -> m () Source # elemseq :: Vector Int -> Int -> b -> b Source #
Vector Vector Int8 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Int8 -> m ( Vector Int8 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Int8 -> m ( Mutable Vector ( PrimState m) Int8 ) Source # basicLength :: Vector Int8 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8 Source # basicUnsafeIndexM :: Monad m => Vector Int8 -> Int -> m Int8 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Int8 -> Vector Int8 -> m () Source # elemseq :: Vector Int8 -> Int8 -> b -> b Source #
Vector Vector Int16 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Int16 -> m ( Vector Int16 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Int16 -> m ( Mutable Vector ( PrimState m) Int16 ) Source # basicLength :: Vector Int16 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16 Source # basicUnsafeIndexM :: Monad m => Vector Int16 -> Int -> m Int16 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Int16 -> Vector Int16 -> m () Source # elemseq :: Vector Int16 -> Int16 -> b -> b Source #
Vector Vector Int32 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Int32 -> m ( Vector Int32 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m ( Mutable Vector ( PrimState m) Int32 ) Source # basicLength :: Vector Int32 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32 Source # basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Int32 -> Vector Int32 -> m () Source # elemseq :: Vector Int32 -> Int32 -> b -> b Source #
Vector Vector Int64 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Int64 -> m ( Vector Int64 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m ( Mutable Vector ( PrimState m) Int64 ) Source # basicLength :: Vector Int64 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64 Source # basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Int64 -> Vector Int64 -> m () Source # elemseq :: Vector Int64 -> Int64 -> b -> b Source #
Vector Vector Word Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Word -> m ( Vector Word ) Source # basicUnsafeThaw :: PrimMonad m => Vector Word -> m ( Mutable Vector ( PrimState m) Word ) Source # basicLength :: Vector Word -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word Source # basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Word -> Vector Word -> m () Source # elemseq :: Vector Word -> Word -> b -> b Source #
Vector Vector Word8 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Word8 -> m ( Vector Word8 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m ( Mutable Vector ( PrimState m) Word8 ) Source # basicLength :: Vector Word8 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8 Source # basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Word8 -> Vector Word8 -> m () Source # elemseq :: Vector Word8 -> Word8 -> b -> b Source #
Vector Vector Word16 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Word16 -> m ( Vector Word16 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m ( Mutable Vector ( PrimState m) Word16 ) Source # basicLength :: Vector Word16 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16 Source # basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Word16 -> Vector Word16 -> m () Source # elemseq :: Vector Word16 -> Word16 -> b -> b Source #
Vector Vector Word32 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Word32 -> m ( Vector Word32 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m ( Mutable Vector ( PrimState m) Word32 ) Source # basicLength :: Vector Word32 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32 Source # basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Word32 -> Vector Word32 -> m () Source # elemseq :: Vector Word32 -> Word32 -> b -> b Source #
Vector Vector Word64 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Word64 -> m ( Vector Word64 ) Source # basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m ( Mutable Vector ( PrimState m) Word64 ) Source # basicLength :: Vector Word64 -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64 Source # basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64 Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Word64 -> Vector Word64 -> m () Source # elemseq :: Vector Word64 -> Word64 -> b -> b Source #
Vector Vector () Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) () -> m ( Vector ()) Source # basicUnsafeThaw :: PrimMonad m => Vector () -> m ( Mutable Vector ( PrimState m) ()) Source # basicLength :: Vector () -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector () -> Vector () Source # basicUnsafeIndexM :: Monad m => Vector () -> Int -> m () Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) () -> Vector () -> m () Source # elemseq :: Vector () -> () -> b -> b Source #
Vector Vector All Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) All -> m ( Vector All ) Source # basicUnsafeThaw :: PrimMonad m => Vector All -> m ( Mutable Vector ( PrimState m) All ) Source # basicLength :: Vector All -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector All -> Vector All Source # basicUnsafeIndexM :: Monad m => Vector All -> Int -> m All Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) All -> Vector All -> m () Source # elemseq :: Vector All -> All -> b -> b Source #
Vector Vector Any Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) Any -> m ( Vector Any ) Source # basicUnsafeThaw :: PrimMonad m => Vector Any -> m ( Mutable Vector ( PrimState m) Any ) Source # basicLength :: Vector Any -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector Any -> Vector Any Source # basicUnsafeIndexM :: Monad m => Vector Any -> Int -> m Any Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) Any -> Vector Any -> m () Source # elemseq :: Vector Any -> Any -> b -> b Source #
Unbox a => Vector Vector ( Complex a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Complex a) -> m ( Vector ( Complex a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Complex a) -> m ( Mutable Vector ( PrimState m) ( Complex a)) Source # basicLength :: Vector ( Complex a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Complex a) -> Vector ( Complex a) Source # basicUnsafeIndexM :: Monad m => Vector ( Complex a) -> Int -> m ( Complex a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Complex a) -> Vector ( Complex a) -> m () Source # elemseq :: Vector ( Complex a) -> Complex a -> b -> b Source #
Unbox a => Vector Vector ( Min a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Min a) -> m ( Vector ( Min a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Min a) -> m ( Mutable Vector ( PrimState m) ( Min a)) Source # basicLength :: Vector ( Min a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Min a) -> Vector ( Min a) Source # basicUnsafeIndexM :: Monad m => Vector ( Min a) -> Int -> m ( Min a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Min a) -> Vector ( Min a) -> m () Source # elemseq :: Vector ( Min a) -> Min a -> b -> b Source #
Unbox a => Vector Vector ( Max a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Max a) -> m ( Vector ( Max a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Max a) -> m ( Mutable Vector ( PrimState m) ( Max a)) Source # basicLength :: Vector ( Max a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Max a) -> Vector ( Max a) Source # basicUnsafeIndexM :: Monad m => Vector ( Max a) -> Int -> m ( Max a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Max a) -> Vector ( Max a) -> m () Source # elemseq :: Vector ( Max a) -> Max a -> b -> b Source #
Unbox a => Vector Vector ( First a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( First a) -> m ( Vector ( First a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( First a) -> m ( Mutable Vector ( PrimState m) ( First a)) Source # basicLength :: Vector ( First a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( First a) -> Vector ( First a) Source # basicUnsafeIndexM :: Monad m => Vector ( First a) -> Int -> m ( First a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( First a) -> Vector ( First a) -> m () Source # elemseq :: Vector ( First a) -> First a -> b -> b Source #
Unbox a => Vector Vector ( Last a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Last a) -> m ( Vector ( Last a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Last a) -> m ( Mutable Vector ( PrimState m) ( Last a)) Source # basicLength :: Vector ( Last a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Last a) -> Vector ( Last a) Source # basicUnsafeIndexM :: Monad m => Vector ( Last a) -> Int -> m ( Last a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Last a) -> Vector ( Last a) -> m () Source # elemseq :: Vector ( Last a) -> Last a -> b -> b Source #
Unbox a => Vector Vector ( WrappedMonoid a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( WrappedMonoid a) -> m ( Vector ( WrappedMonoid a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( WrappedMonoid a) -> m ( Mutable Vector ( PrimState m) ( WrappedMonoid a)) Source # basicLength :: Vector ( WrappedMonoid a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( WrappedMonoid a) -> Vector ( WrappedMonoid a) Source # basicUnsafeIndexM :: Monad m => Vector ( WrappedMonoid a) -> Int -> m ( WrappedMonoid a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( WrappedMonoid a) -> Vector ( WrappedMonoid a) -> m () Source # elemseq :: Vector ( WrappedMonoid a) -> WrappedMonoid a -> b -> b Source #
Unbox a => Vector Vector ( Identity a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Identity a) -> m ( Vector ( Identity a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Identity a) -> m ( Mutable Vector ( PrimState m) ( Identity a)) Source # basicLength :: Vector ( Identity a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Identity a) -> Vector ( Identity a) Source # basicUnsafeIndexM :: Monad m => Vector ( Identity a) -> Int -> m ( Identity a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Identity a) -> Vector ( Identity a) -> m () Source # elemseq :: Vector ( Identity a) -> Identity a -> b -> b Source #
Unbox a => Vector Vector ( Dual a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Dual a) -> m ( Vector ( Dual a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Dual a) -> m ( Mutable Vector ( PrimState m) ( Dual a)) Source # basicLength :: Vector ( Dual a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Dual a) -> Vector ( Dual a) Source # basicUnsafeIndexM :: Monad m => Vector ( Dual a) -> Int -> m ( Dual a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Dual a) -> Vector ( Dual a) -> m () Source # elemseq :: Vector ( Dual a) -> Dual a -> b -> b Source #
Unbox a => Vector Vector ( Sum a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Sum a) -> m ( Vector ( Sum a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Sum a) -> m ( Mutable Vector ( PrimState m) ( Sum a)) Source # basicLength :: Vector ( Sum a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Sum a) -> Vector ( Sum a) Source # basicUnsafeIndexM :: Monad m => Vector ( Sum a) -> Int -> m ( Sum a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Sum a) -> Vector ( Sum a) -> m () Source # elemseq :: Vector ( Sum a) -> Sum a -> b -> b Source #
Unbox a => Vector Vector ( Product a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Product a) -> m ( Vector ( Product a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Product a) -> m ( Mutable Vector ( PrimState m) ( Product a)) Source # basicLength :: Vector ( Product a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Product a) -> Vector ( Product a) Source # basicUnsafeIndexM :: Monad m => Vector ( Product a) -> Int -> m ( Product a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Product a) -> Vector ( Product a) -> m () Source # elemseq :: Vector ( Product a) -> Product a -> b -> b Source #
Unbox a => Vector Vector ( Down a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Down a) -> m ( Vector ( Down a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Down a) -> m ( Mutable Vector ( PrimState m) ( Down a)) Source # basicLength :: Vector ( Down a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Down a) -> Vector ( Down a) Source # basicUnsafeIndexM :: Monad m => Vector ( Down a) -> Int -> m ( Down a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Down a) -> Vector ( Down a) -> m () Source # elemseq :: Vector ( Down a) -> Down a -> b -> b Source #
( Unbox a, Unbox b) => Vector Vector (a, b) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) (a, b) -> m ( Vector (a, b)) Source # basicUnsafeThaw :: PrimMonad m => Vector (a, b) -> m ( Mutable Vector ( PrimState m) (a, b)) Source # basicLength :: Vector (a, b) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector (a, b) -> Vector (a, b) Source # basicUnsafeIndexM :: Monad m => Vector (a, b) -> Int -> m (a, b) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) (a, b) -> Vector (a, b) -> m () Source # elemseq :: Vector (a, b) -> (a, b) -> b0 -> b0 Source #
( Unbox a, Unbox b) => Vector Vector ( Arg a b) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Arg a b) -> m ( Vector ( Arg a b)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Arg a b) -> m ( Mutable Vector ( PrimState m) ( Arg a b)) Source # basicLength :: Vector ( Arg a b) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Arg a b) -> Vector ( Arg a b) Source # basicUnsafeIndexM :: Monad m => Vector ( Arg a b) -> Int -> m ( Arg a b) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Arg a b) -> Vector ( Arg a b) -> m () Source # elemseq :: Vector ( Arg a b) -> Arg a b -> b0 -> b0 Source #
( Unbox a, Unbox b, Unbox c) => Vector Vector (a, b, c) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) (a, b, c) -> m ( Vector (a, b, c)) Source # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c) -> m ( Mutable Vector ( PrimState m) (a, b, c)) Source # basicLength :: Vector (a, b, c) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c) -> Vector (a, b, c) Source # basicUnsafeIndexM :: Monad m => Vector (a, b, c) -> Int -> m (a, b, c) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) (a, b, c) -> Vector (a, b, c) -> m () Source # elemseq :: Vector (a, b, c) -> (a, b, c) -> b0 -> b0 Source #
Unbox a => Vector Vector ( Const a b) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Const a b) -> m ( Vector ( Const a b)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Const a b) -> m ( Mutable Vector ( PrimState m) ( Const a b)) Source # basicLength :: Vector ( Const a b) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Const a b) -> Vector ( Const a b) Source # basicUnsafeIndexM :: Monad m => Vector ( Const a b) -> Int -> m ( Const a b) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Const a b) -> Vector ( Const a b) -> m () Source # elemseq :: Vector ( Const a b) -> Const a b -> b0 -> b0 Source #
Unbox (f a) => Vector Vector ( Alt f a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Alt f a) -> m ( Vector ( Alt f a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Alt f a) -> m ( Mutable Vector ( PrimState m) ( Alt f a)) Source # basicLength :: Vector ( Alt f a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Alt f a) -> Vector ( Alt f a) Source # basicUnsafeIndexM :: Monad m => Vector ( Alt f a) -> Int -> m ( Alt f a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Alt f a) -> Vector ( Alt f a) -> m () Source # elemseq :: Vector ( Alt f a) -> Alt f a -> b -> b Source #
( Unbox a, Unbox b, Unbox c, Unbox d) => Vector Vector (a, b, c, d) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) (a, b, c, d) -> m ( Vector (a, b, c, d)) Source # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d) -> m ( Mutable Vector ( PrimState m) (a, b, c, d)) Source # basicLength :: Vector (a, b, c, d) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d) -> Vector (a, b, c, d) Source # basicUnsafeIndexM :: Monad m => Vector (a, b, c, d) -> Int -> m (a, b, c, d) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) (a, b, c, d) -> Vector (a, b, c, d) -> m () Source # elemseq :: Vector (a, b, c, d) -> (a, b, c, d) -> b0 -> b0 Source #
( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector Vector (a, b, c, d, e) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) (a, b, c, d, e) -> m ( Vector (a, b, c, d, e)) Source # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e) -> m ( Mutable Vector ( PrimState m) (a, b, c, d, e)) Source # basicLength :: Vector (a, b, c, d, e) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e) -> Vector (a, b, c, d, e) Source # basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e) -> Int -> m (a, b, c, d, e) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) (a, b, c, d, e) -> Vector (a, b, c, d, e) -> m () Source # elemseq :: Vector (a, b, c, d, e) -> (a, b, c, d, e) -> b0 -> b0 Source #
Unbox (f (g a)) => Vector Vector ( Compose f g a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) ( Compose f g a) -> m ( Vector ( Compose f g a)) Source # basicUnsafeThaw :: PrimMonad m => Vector ( Compose f g a) -> m ( Mutable Vector ( PrimState m) ( Compose f g a)) Source # basicLength :: Vector ( Compose f g a) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector ( Compose f g a) -> Vector ( Compose f g a) Source # basicUnsafeIndexM :: Monad m => Vector ( Compose f g a) -> Int -> m ( Compose f g a) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) ( Compose f g a) -> Vector ( Compose f g a) -> m () Source # elemseq :: Vector ( Compose f g a) -> Compose f g a -> b -> b Source #
( Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector Vector (a, b, c, d, e, f) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector ( PrimState m) (a, b, c, d, e, f) -> m ( Vector (a, b, c, d, e, f)) Source # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e, f) -> m ( Mutable Vector ( PrimState m) (a, b, c, d, e, f)) Source # basicLength :: Vector (a, b, c, d, e, f) -> Int Source # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) Source # basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f) Source # basicUnsafeCopy :: PrimMonad m => Mutable Vector ( PrimState m) (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> m () Source # elemseq :: Vector (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> b0 -> b0 Source #
Unbox e => IsList ( Vector e) Source #
Instance details Defined in Data.Vector.Unboxed Associated Types type Item ( Vector e) Source # Methods fromList :: [ Item ( Vector e)] -> Vector e Source # fromListN :: Int -> [ Item ( Vector e)] -> Vector e Source # toList :: Vector e -> [ Item ( Vector e)] Source #
( Unbox a, Eq a) => Eq ( Vector a) Source #
Instance details Defined in Data.Vector.Unboxed Methods (==) :: Vector a -> Vector a -> Bool Source # (/=) :: Vector a -> Vector a -> Bool Source #
( Data a, Unbox a) => Data ( Vector a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods gfoldl :: ( forall d b. Data d => c (d -> b) -> d -> c b) -> ( forall g. g -> c g) -> Vector a -> c ( Vector a) Source # gunfold :: ( forall b r. Data b => c (b -> r) -> c r) -> ( forall r. r -> c r) -> Constr -> c ( Vector a) Source # toConstr :: Vector a -> Constr Source # dataTypeOf :: Vector a -> DataType Source # dataCast1 :: Typeable t => ( forall d. Data d => c (t d)) -> Maybe (c ( Vector a)) Source # dataCast2 :: Typeable t => ( forall d e. ( Data d, Data e) => c (t d e)) -> Maybe (c ( Vector a)) Source # gmapT :: ( forall b. Data b => b -> b) -> Vector a -> Vector a Source # gmapQl :: (r -> r' -> r) -> r -> ( forall d. Data d => d -> r') -> Vector a -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> ( forall d. Data d => d -> r') -> Vector a -> r Source # gmapQ :: ( forall d. Data d => d -> u) -> Vector a -> [u] Source # gmapQi :: Int -> ( forall d. Data d => d -> u) -> Vector a -> u Source # gmapM :: Monad m => ( forall d. Data d => d -> m d) -> Vector a -> m ( Vector a) Source # gmapMp :: MonadPlus m => ( forall d. Data d => d -> m d) -> Vector a -> m ( Vector a) Source # gmapMo :: MonadPlus m => ( forall d. Data d => d -> m d) -> Vector a -> m ( Vector a) Source #
( Unbox a, Ord a) => Ord ( Vector a) Source #
Instance details Defined in Data.Vector.Unboxed Methods compare :: Vector a -> Vector a -> Ordering Source # (<) :: Vector a -> Vector a -> Bool Source # (<=) :: Vector a -> Vector a -> Bool Source # (>) :: Vector a -> Vector a -> Bool Source # (>=) :: Vector a -> Vector a -> Bool Source # max :: Vector a -> Vector a -> Vector a Source # min :: Vector a -> Vector a -> Vector a Source #
( Read a, Unbox a) => Read ( Vector a) Source #
Instance details Defined in Data.Vector.Unboxed Methods readsPrec :: Int -> ReadS ( Vector a) Source # readList :: ReadS [ Vector a] Source # readPrec :: ReadPrec ( Vector a) Source # readListPrec :: ReadPrec [ Vector a] Source #
( Show a, Unbox a) => Show ( Vector a) Source #
Instance details Defined in Data.Vector.Unboxed Methods showsPrec :: Int -> Vector a -> ShowS Source # show :: Vector a -> String Source # showList :: [ Vector a] -> ShowS Source #
Unbox a => Semigroup ( Vector a) Source #
Instance details Defined in Data.Vector.Unboxed Methods (<>) :: Vector a -> Vector a -> Vector a Source # sconcat :: NonEmpty ( Vector a) -> Vector a Source # stimes :: Integral b => b -> Vector a -> Vector a Source #
Unbox a => Monoid ( Vector a) Source #
Instance details Defined in Data.Vector.Unboxed Methods mempty :: Vector a Source # mappend :: Vector a -> Vector a -> Vector a Source # mconcat :: [ Vector a] -> Vector a Source #
NFData ( Vector a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: Vector a -> () Source #
type Mutable Vector Source #
Instance details Defined in Data.Vector.Unboxed.Base type Mutable Vector = MVector
newtype Vector Bool Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Bool = V_Bool ( Vector Word8 )
newtype Vector Char Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Char = V_Char ( Vector Char )
newtype Vector Double Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Double = V_Double ( Vector Double )
newtype Vector Float Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Float = V_Float ( Vector Float )
newtype Vector Int Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int = V_Int ( Vector Int )
newtype Vector Int8 Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int8 = V_Int8 ( Vector Int8 )
newtype Vector Int16 Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int16 = V_Int16 ( Vector Int16 )
newtype Vector Int32 Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int32 = V_Int32 ( Vector Int32 )
newtype Vector Int64 Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int64 = V_Int64 ( Vector Int64 )
newtype Vector Word Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word = V_Word ( Vector Word )
newtype Vector Word8 Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word8 = V_Word8 ( Vector Word8 )
newtype Vector Word16 Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word16 = V_Word16 ( Vector Word16 )
newtype Vector Word32 Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word32 = V_Word32 ( Vector Word32 )
newtype Vector Word64 Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word64 = V_Word64 ( Vector Word64 )
newtype Vector () Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector () = V_Unit Int
newtype Vector All Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector All = V_All ( Vector Bool )
newtype Vector Any Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Any = V_Any ( Vector Bool )
type Item ( Vector e) Source #
Instance details Defined in Data.Vector.Unboxed type Item ( Vector e) = e
newtype Vector ( Complex a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Complex a) = V_Complex ( Vector (a, a))
newtype Vector ( Min a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Min a) = V_Min ( Vector a)
newtype Vector ( Max a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Max a) = V_Max ( Vector a)
newtype Vector ( First a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( First a) = V_First ( Vector a)
newtype Vector ( Last a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Last a) = V_Last ( Vector a)
newtype Vector ( WrappedMonoid a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( WrappedMonoid a) = V_WrappedMonoid ( Vector a)
newtype Vector ( Identity a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Identity a) = V_Identity ( Vector a)
newtype Vector ( Dual a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Dual a) = V_Dual ( Vector a)
newtype Vector ( Sum a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Sum a) = V_Sum ( Vector a)
newtype Vector ( Product a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Product a) = V_Product ( Vector a)
newtype Vector ( Down a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Down a) = V_Down ( Vector a)
data Vector (a, b) Source #
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b) = V_2 ! Int !( Vector a) !( Vector b)
newtype Vector ( Arg a b) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Arg a b) = V_Arg ( Vector (a, b))
data Vector (a, b, c) Source #
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b, c) = V_3 ! Int !( Vector a) !( Vector b) !( Vector c)
newtype Vector ( Const a b) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Const a b) = V_Const ( Vector a)
newtype Vector ( Alt f a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Alt f a) = V_Alt ( Vector (f a))
data Vector (a, b, c, d) Source #
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b, c, d) = V_4 ! Int !( Vector a) !( Vector b) !( Vector c) !( Vector d)
data Vector (a, b, c, d, e) Source #
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b, c, d, e) = V_5 ! Int !( Vector a) !( Vector b) !( Vector c) !( Vector d) !( Vector e)
newtype Vector ( Compose f g a) Source #
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector ( Compose f g a) = V_Compose ( Vector (f (g a)))
data Vector (a, b, c, d, e, f) Source #
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b, c, d, e, f) = V_6 ! Int !( Vector a) !( Vector b) !( Vector c) !( Vector d) !( Vector e) !( Vector f)

data family MVector s a Source #

Instances

Instances details

MVector MVector Bool Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Bool -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool Source # basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Bool ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Bool -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m ( MVector ( PrimState m) Bool ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Bool -> Int -> m Bool Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Bool -> Int -> Bool -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Bool -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Bool -> Bool -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Bool -> MVector ( PrimState m) Bool -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Bool -> MVector ( PrimState m) Bool -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Bool -> Int -> m ( MVector ( PrimState m) Bool ) Source #
MVector MVector Char Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Char -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char Source # basicOverlaps :: MVector s Char -> MVector s Char -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Char ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Char -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m ( MVector ( PrimState m) Char ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Char -> Int -> m Char Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Char -> Int -> Char -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Char -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Char -> Char -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Char -> MVector ( PrimState m) Char -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Char -> MVector ( PrimState m) Char -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Char -> Int -> m ( MVector ( PrimState m) Char ) Source #
MVector MVector Double Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Double -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double Source # basicOverlaps :: MVector s Double -> MVector s Double -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Double ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Double -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m ( MVector ( PrimState m) Double ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Double -> Int -> m Double Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Double -> Int -> Double -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Double -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Double -> Double -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Double -> MVector ( PrimState m) Double -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Double -> MVector ( PrimState m) Double -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Double -> Int -> m ( MVector ( PrimState m) Double ) Source #
MVector MVector Float Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Float -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float Source # basicOverlaps :: MVector s Float -> MVector s Float -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Float ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Float -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m ( MVector ( PrimState m) Float ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Float -> Int -> m Float Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Float -> Int -> Float -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Float -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Float -> Float -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Float -> MVector ( PrimState m) Float -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Float -> MVector ( PrimState m) Float -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Float -> Int -> m ( MVector ( PrimState m) Float ) Source #
MVector MVector Int Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int Source # basicOverlaps :: MVector s Int -> MVector s Int -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Int ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Int -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m ( MVector ( PrimState m) Int ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Int -> Int -> m Int Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Int -> Int -> Int -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Int -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Int -> Int -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Int -> MVector ( PrimState m) Int -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Int -> MVector ( PrimState m) Int -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Int -> Int -> m ( MVector ( PrimState m) Int ) Source #
MVector MVector Int8 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int8 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Int8 -> MVector s Int8 Source # basicOverlaps :: MVector s Int8 -> MVector s Int8 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Int8 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Int8 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Int8 -> m ( MVector ( PrimState m) Int8 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Int8 -> Int -> m Int8 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Int8 -> Int -> Int8 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Int8 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Int8 -> Int8 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Int8 -> MVector ( PrimState m) Int8 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Int8 -> MVector ( PrimState m) Int8 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Int8 -> Int -> m ( MVector ( PrimState m) Int8 ) Source #
MVector MVector Int16 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int16 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Int16 -> MVector s Int16 Source # basicOverlaps :: MVector s Int16 -> MVector s Int16 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Int16 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Int16 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Int16 -> m ( MVector ( PrimState m) Int16 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Int16 -> Int -> m Int16 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Int16 -> Int -> Int16 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Int16 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Int16 -> Int16 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Int16 -> MVector ( PrimState m) Int16 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Int16 -> MVector ( PrimState m) Int16 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Int16 -> Int -> m ( MVector ( PrimState m) Int16 ) Source #
MVector MVector Int32 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int32 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Int32 -> MVector s Int32 Source # basicOverlaps :: MVector s Int32 -> MVector s Int32 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Int32 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Int32 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Int32 -> m ( MVector ( PrimState m) Int32 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Int32 -> Int -> m Int32 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Int32 -> Int -> Int32 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Int32 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Int32 -> Int32 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Int32 -> MVector ( PrimState m) Int32 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Int32 -> MVector ( PrimState m) Int32 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Int32 -> Int -> m ( MVector ( PrimState m) Int32 ) Source #
MVector MVector Int64 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int64 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64 Source # basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Int64 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Int64 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m ( MVector ( PrimState m) Int64 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Int64 -> Int -> m Int64 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Int64 -> Int -> Int64 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Int64 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Int64 -> Int64 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Int64 -> MVector ( PrimState m) Int64 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Int64 -> MVector ( PrimState m) Int64 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Int64 -> Int -> m ( MVector ( PrimState m) Int64 ) Source #
MVector MVector Word Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word Source # basicOverlaps :: MVector s Word -> MVector s Word -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Word ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Word -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m ( MVector ( PrimState m) Word ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Word -> Int -> m Word Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Word -> Int -> Word -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Word -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Word -> Word -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Word -> MVector ( PrimState m) Word -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Word -> MVector ( PrimState m) Word -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Word -> Int -> m ( MVector ( PrimState m) Word ) Source #
MVector MVector Word8 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word8 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8 Source # basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Word8 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Word8 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m ( MVector ( PrimState m) Word8 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Word8 -> Int -> m Word8 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Word8 -> Int -> Word8 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Word8 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Word8 -> Word8 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Word8 -> MVector ( PrimState m) Word8 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Word8 -> MVector ( PrimState m) Word8 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Word8 -> Int -> m ( MVector ( PrimState m) Word8 ) Source #
MVector MVector Word16 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word16 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Word16 -> MVector s Word16 Source # basicOverlaps :: MVector s Word16 -> MVector s Word16 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Word16 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Word16 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Word16 -> m ( MVector ( PrimState m) Word16 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Word16 -> Int -> m Word16 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Word16 -> Int -> Word16 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Word16 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Word16 -> Word16 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Word16 -> MVector ( PrimState m) Word16 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Word16 -> MVector ( PrimState m) Word16 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Word16 -> Int -> m ( MVector ( PrimState m) Word16 ) Source #
MVector MVector Word32 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word32 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Word32 -> MVector s Word32 Source # basicOverlaps :: MVector s Word32 -> MVector s Word32 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Word32 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Word32 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Word32 -> m ( MVector ( PrimState m) Word32 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Word32 -> Int -> m Word32 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Word32 -> Int -> Word32 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Word32 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Word32 -> Word32 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Word32 -> MVector ( PrimState m) Word32 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Word32 -> MVector ( PrimState m) Word32 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Word32 -> Int -> m ( MVector ( PrimState m) Word32 ) Source #
MVector MVector Word64 Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word64 -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Word64 -> MVector s Word64 Source # basicOverlaps :: MVector s Word64 -> MVector s Word64 -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Word64 ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Word64 -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Word64 -> m ( MVector ( PrimState m) Word64 ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Word64 -> Int -> m Word64 Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Word64 -> Int -> Word64 -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Word64 -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Word64 -> Word64 -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Word64 -> MVector ( PrimState m) Word64 -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Word64 -> MVector ( PrimState m) Word64 -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Word64 -> Int -> m ( MVector ( PrimState m) Word64 ) Source #
MVector MVector () Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s () -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s () -> MVector s () Source # basicOverlaps :: MVector s () -> MVector s () -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ()) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) () -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> () -> m ( MVector ( PrimState m) ()) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) () -> Int -> m () Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) () -> Int -> () -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) () -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) () -> () -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) () -> MVector ( PrimState m) () -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) () -> MVector ( PrimState m) () -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) () -> Int -> m ( MVector ( PrimState m) ()) Source #
MVector MVector All Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s All -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s All -> MVector s All Source # basicOverlaps :: MVector s All -> MVector s All -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) All ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) All -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> All -> m ( MVector ( PrimState m) All ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) All -> Int -> m All Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) All -> Int -> All -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) All -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) All -> All -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) All -> MVector ( PrimState m) All -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) All -> MVector ( PrimState m) All -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) All -> Int -> m ( MVector ( PrimState m) All ) Source #
MVector MVector Any Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Any -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s Any -> MVector s Any Source # basicOverlaps :: MVector s Any -> MVector s Any -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) Any ) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) Any -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Any -> m ( MVector ( PrimState m) Any ) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) Any -> Int -> m Any Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) Any -> Int -> Any -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) Any -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) Any -> Any -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) Any -> MVector ( PrimState m) Any -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) Any -> MVector ( PrimState m) Any -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) Any -> Int -> m ( MVector ( PrimState m) Any ) Source #
Unbox a => MVector MVector ( Complex a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Complex a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Complex a) -> MVector s ( Complex a) Source # basicOverlaps :: MVector s ( Complex a) -> MVector s ( Complex a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Complex a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Complex a -> m ( MVector ( PrimState m) ( Complex a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> Int -> m ( Complex a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> Int -> Complex a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> Complex a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> MVector ( PrimState m) ( Complex a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> MVector ( PrimState m) ( Complex a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Complex a) -> Int -> m ( MVector ( PrimState m) ( Complex a)) Source #
Unbox a => MVector MVector ( Min a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Min a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Min a) -> MVector s ( Min a) Source # basicOverlaps :: MVector s ( Min a) -> MVector s ( Min a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Min a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Min a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Min a -> m ( MVector ( PrimState m) ( Min a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Min a) -> Int -> m ( Min a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Min a) -> Int -> Min a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Min a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Min a) -> Min a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Min a) -> MVector ( PrimState m) ( Min a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Min a) -> MVector ( PrimState m) ( Min a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Min a) -> Int -> m ( MVector ( PrimState m) ( Min a)) Source #
Unbox a => MVector MVector ( Max a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Max a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Max a) -> MVector s ( Max a) Source # basicOverlaps :: MVector s ( Max a) -> MVector s ( Max a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Max a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Max a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Max a -> m ( MVector ( PrimState m) ( Max a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Max a) -> Int -> m ( Max a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Max a) -> Int -> Max a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Max a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Max a) -> Max a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Max a) -> MVector ( PrimState m) ( Max a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Max a) -> MVector ( PrimState m) ( Max a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Max a) -> Int -> m ( MVector ( PrimState m) ( Max a)) Source #
Unbox a => MVector MVector ( First a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( First a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( First a) -> MVector s ( First a) Source # basicOverlaps :: MVector s ( First a) -> MVector s ( First a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( First a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( First a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> First a -> m ( MVector ( PrimState m) ( First a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( First a) -> Int -> m ( First a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( First a) -> Int -> First a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( First a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( First a) -> First a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( First a) -> MVector ( PrimState m) ( First a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( First a) -> MVector ( PrimState m) ( First a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( First a) -> Int -> m ( MVector ( PrimState m) ( First a)) Source #
Unbox a => MVector MVector ( Last a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Last a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Last a) -> MVector s ( Last a) Source # basicOverlaps :: MVector s ( Last a) -> MVector s ( Last a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Last a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( Last a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> Last a -> m ( MVector ( PrimState m) ( Last a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( Last a) -> Int -> m ( Last a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( Last a) -> Int -> Last a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( Last a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( Last a) -> Last a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( Last a) -> MVector ( PrimState m) ( Last a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( Last a) -> MVector ( PrimState m) ( Last a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( Last a) -> Int -> m ( MVector ( PrimState m) ( Last a)) Source #
Unbox a => MVector MVector ( WrappedMonoid a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( WrappedMonoid a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( WrappedMonoid a) -> MVector s ( WrappedMonoid a) Source # basicOverlaps :: MVector s ( WrappedMonoid a) -> MVector s ( WrappedMonoid a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( WrappedMonoid a)) Source # basicInitialize :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> m () Source # basicUnsafeReplicate :: PrimMonad m => Int -> WrappedMonoid a -> m ( MVector ( PrimState m) ( WrappedMonoid a)) Source # basicUnsafeRead :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> Int -> m ( WrappedMonoid a) Source # basicUnsafeWrite :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> Int -> WrappedMonoid a -> m () Source # basicClear :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> m () Source # basicSet :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> WrappedMonoid a -> m () Source # basicUnsafeCopy :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> MVector ( PrimState m) ( WrappedMonoid a) -> m () Source # basicUnsafeMove :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> MVector ( PrimState m) ( WrappedMonoid a) -> m () Source # basicUnsafeGrow :: PrimMonad m => MVector ( PrimState m) ( WrappedMonoid a) -> Int -> m ( MVector ( PrimState m) ( WrappedMonoid a)) Source #
Unbox a => MVector MVector ( Identity a) Source #
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s ( Identity a) -> Int Source # basicUnsafeSlice :: Int -> Int -> MVector s ( Identity a) -> MVector s ( Identity a) Source # basicOverlaps :: MVector s ( Identity a) -> MVector s ( Identity a) -> Bool Source # basicUnsafeNew :: PrimMonad m => Int -> m ( MVector ( PrimState m) ( Identity a)) Source #