Safe Haskell	None
Language	Haskell2010

Rebase.Data.Vector.Unboxed

Documentation

indexed :: Unbox a => Vector a -> Vector (Int, a) #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a, Vector b) #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b) #

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

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

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

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

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

empty :: Unbox a => Vector a #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

dropWhile :: Unbox a => (a -> Bool) -> 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) #

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

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

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

and :: Vector Bool -> Bool #

or :: Vector Bool -> Bool #

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

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

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

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

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

zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a -> Vector b -> Vector c -> Vector (a, b, c) #

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 #

unzip3 :: (Unbox a, Unbox b, Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c) #

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

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

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

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

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

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

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

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

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

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 #

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

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

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

zipWithM :: (Monad m, Unbox a, Unbox b, Unbox c) => (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 () #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

update :: Unbox a => Vector a -> Vector (Int, a) -> Vector a #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 #

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

uniq :: (Unbox a, Eq a) => Vector a -> Vector 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 a #

fold1M' :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> m 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) #

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

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

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

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 #

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

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

data family Vector a #

Instances

Instances details

NFData1 Vector
Instance details Defined in Data.Vector.Unboxed.Base Methods liftRnf :: (a -> ()) -> Vector a -> () #
Vector Vector All
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s All -> ST s (Vector All) # basicUnsafeThaw :: Vector All -> ST s (Mutable Vector s All) # basicLength :: Vector All -> Int # basicUnsafeSlice :: Int -> Int -> Vector All -> Vector All # basicUnsafeIndexM :: Vector All -> Int -> Box All # basicUnsafeCopy :: Mutable Vector s All -> Vector All -> ST s () # elemseq :: Vector All -> All -> b -> b #
Vector Vector Any
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Any -> ST s (Vector Any) # basicUnsafeThaw :: Vector Any -> ST s (Mutable Vector s Any) # basicLength :: Vector Any -> Int # basicUnsafeSlice :: Int -> Int -> Vector Any -> Vector Any # basicUnsafeIndexM :: Vector Any -> Int -> Box Any # basicUnsafeCopy :: Mutable Vector s Any -> Vector Any -> ST s () # elemseq :: Vector Any -> Any -> b -> b #
Vector Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Int16 -> ST s (Vector Int16) # basicUnsafeThaw :: Vector Int16 -> ST s (Mutable Vector s Int16) # basicLength :: Vector Int16 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16 # basicUnsafeIndexM :: Vector Int16 -> Int -> Box Int16 # basicUnsafeCopy :: Mutable Vector s Int16 -> Vector Int16 -> ST s () # elemseq :: Vector Int16 -> Int16 -> b -> b #
Vector Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Int32 -> ST s (Vector Int32) # basicUnsafeThaw :: Vector Int32 -> ST s (Mutable Vector s Int32) # basicLength :: Vector Int32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32 # basicUnsafeIndexM :: Vector Int32 -> Int -> Box Int32 # basicUnsafeCopy :: Mutable Vector s Int32 -> Vector Int32 -> ST s () # elemseq :: Vector Int32 -> Int32 -> b -> b #
Vector Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Int64 -> ST s (Vector Int64) # basicUnsafeThaw :: Vector Int64 -> ST s (Mutable Vector s Int64) # basicLength :: Vector Int64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64 # basicUnsafeIndexM :: Vector Int64 -> Int -> Box Int64 # basicUnsafeCopy :: Mutable Vector s Int64 -> Vector Int64 -> ST s () # elemseq :: Vector Int64 -> Int64 -> b -> b #
Vector Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Int8 -> ST s (Vector Int8) # basicUnsafeThaw :: Vector Int8 -> ST s (Mutable Vector s Int8) # basicLength :: Vector Int8 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8 # basicUnsafeIndexM :: Vector Int8 -> Int -> Box Int8 # basicUnsafeCopy :: Mutable Vector s Int8 -> Vector Int8 -> ST s () # elemseq :: Vector Int8 -> Int8 -> b -> b #
Vector Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Word16 -> ST s (Vector Word16) # basicUnsafeThaw :: Vector Word16 -> ST s (Mutable Vector s Word16) # basicLength :: Vector Word16 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16 # basicUnsafeIndexM :: Vector Word16 -> Int -> Box Word16 # basicUnsafeCopy :: Mutable Vector s Word16 -> Vector Word16 -> ST s () # elemseq :: Vector Word16 -> Word16 -> b -> b #
Vector Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Word32 -> ST s (Vector Word32) # basicUnsafeThaw :: Vector Word32 -> ST s (Mutable Vector s Word32) # basicLength :: Vector Word32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32 # basicUnsafeIndexM :: Vector Word32 -> Int -> Box Word32 # basicUnsafeCopy :: Mutable Vector s Word32 -> Vector Word32 -> ST s () # elemseq :: Vector Word32 -> Word32 -> b -> b #
Vector Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Word64 -> ST s (Vector Word64) # basicUnsafeThaw :: Vector Word64 -> ST s (Mutable Vector s Word64) # basicLength :: Vector Word64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64 # basicUnsafeIndexM :: Vector Word64 -> Int -> Box Word64 # basicUnsafeCopy :: Mutable Vector s Word64 -> Vector Word64 -> ST s () # elemseq :: Vector Word64 -> Word64 -> b -> b #
Vector Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Word8 -> ST s (Vector Word8) # basicUnsafeThaw :: Vector Word8 -> ST s (Mutable Vector s Word8) # basicLength :: Vector Word8 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8 # basicUnsafeIndexM :: Vector Word8 -> Int -> Box Word8 # basicUnsafeCopy :: Mutable Vector s Word8 -> Vector Word8 -> ST s () # elemseq :: Vector Word8 -> Word8 -> b -> b #
Vector Vector ()
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s () -> ST s (Vector ()) # basicUnsafeThaw :: Vector () -> ST s (Mutable Vector s ()) # basicLength :: Vector () -> Int # basicUnsafeSlice :: Int -> Int -> Vector () -> Vector () # basicUnsafeIndexM :: Vector () -> Int -> Box () # basicUnsafeCopy :: Mutable Vector s () -> Vector () -> ST s () # elemseq :: Vector () -> () -> b -> b #
Vector Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Bool -> ST s (Vector Bool) # basicUnsafeThaw :: Vector Bool -> ST s (Mutable Vector s Bool) # basicLength :: Vector Bool -> Int # basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool # basicUnsafeIndexM :: Vector Bool -> Int -> Box Bool # basicUnsafeCopy :: Mutable Vector s Bool -> Vector Bool -> ST s () # elemseq :: Vector Bool -> Bool -> b -> b #
Vector Vector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Char -> ST s (Vector Char) # basicUnsafeThaw :: Vector Char -> ST s (Mutable Vector s Char) # basicLength :: Vector Char -> Int # basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char # basicUnsafeIndexM :: Vector Char -> Int -> Box Char # basicUnsafeCopy :: Mutable Vector s Char -> Vector Char -> ST s () # elemseq :: Vector Char -> Char -> b -> b #
Vector Vector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Double -> ST s (Vector Double) # basicUnsafeThaw :: Vector Double -> ST s (Mutable Vector s Double) # basicLength :: Vector Double -> Int # basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double # basicUnsafeIndexM :: Vector Double -> Int -> Box Double # basicUnsafeCopy :: Mutable Vector s Double -> Vector Double -> ST s () # elemseq :: Vector Double -> Double -> b -> b #
Vector Vector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Float -> ST s (Vector Float) # basicUnsafeThaw :: Vector Float -> ST s (Mutable Vector s Float) # basicLength :: Vector Float -> Int # basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float # basicUnsafeIndexM :: Vector Float -> Int -> Box Float # basicUnsafeCopy :: Mutable Vector s Float -> Vector Float -> ST s () # elemseq :: Vector Float -> Float -> b -> b #
Vector Vector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Int -> ST s (Vector Int) # basicUnsafeThaw :: Vector Int -> ST s (Mutable Vector s Int) # basicLength :: Vector Int -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int # basicUnsafeIndexM :: Vector Int -> Int -> Box Int # basicUnsafeCopy :: Mutable Vector s Int -> Vector Int -> ST s () # elemseq :: Vector Int -> Int -> b -> b #
Vector Vector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Word -> ST s (Vector Word) # basicUnsafeThaw :: Vector Word -> ST s (Mutable Vector s Word) # basicLength :: Vector Word -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word # basicUnsafeIndexM :: Vector Word -> Int -> Box Word # basicUnsafeCopy :: Mutable Vector s Word -> Vector Word -> ST s () # elemseq :: Vector Word -> Word -> b -> b #
Unbox a => Vector Vector (Complex a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Complex a) -> ST s (Vector (Complex a)) # basicUnsafeThaw :: Vector (Complex a) -> ST s (Mutable Vector s (Complex a)) # basicLength :: Vector (Complex a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a) # basicUnsafeIndexM :: Vector (Complex a) -> Int -> Box (Complex a) # basicUnsafeCopy :: Mutable Vector s (Complex a) -> Vector (Complex a) -> ST s () # elemseq :: Vector (Complex a) -> Complex a -> b -> b #
Unbox a => Vector Vector (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Identity a) -> ST s (Vector (Identity a)) # basicUnsafeThaw :: Vector (Identity a) -> ST s (Mutable Vector s (Identity a)) # basicLength :: Vector (Identity a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Identity a) -> Vector (Identity a) # basicUnsafeIndexM :: Vector (Identity a) -> Int -> Box (Identity a) # basicUnsafeCopy :: Mutable Vector s (Identity a) -> Vector (Identity a) -> ST s () # elemseq :: Vector (Identity a) -> Identity a -> b -> b #
Unbox a => Vector Vector (Down a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Down a) -> ST s (Vector (Down a)) # basicUnsafeThaw :: Vector (Down a) -> ST s (Mutable Vector s (Down a)) # basicLength :: Vector (Down a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Down a) -> Vector (Down a) # basicUnsafeIndexM :: Vector (Down a) -> Int -> Box (Down a) # basicUnsafeCopy :: Mutable Vector s (Down a) -> Vector (Down a) -> ST s () # elemseq :: Vector (Down a) -> Down a -> b -> b #
Unbox a => Vector Vector (First a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (First a) -> ST s (Vector (First a)) # basicUnsafeThaw :: Vector (First a) -> ST s (Mutable Vector s (First a)) # basicLength :: Vector (First a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (First a) -> Vector (First a) # basicUnsafeIndexM :: Vector (First a) -> Int -> Box (First a) # basicUnsafeCopy :: Mutable Vector s (First a) -> Vector (First a) -> ST s () # elemseq :: Vector (First a) -> First a -> b -> b #
Unbox a => Vector Vector (Last a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Last a) -> ST s (Vector (Last a)) # basicUnsafeThaw :: Vector (Last a) -> ST s (Mutable Vector s (Last a)) # basicLength :: Vector (Last a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Last a) -> Vector (Last a) # basicUnsafeIndexM :: Vector (Last a) -> Int -> Box (Last a) # basicUnsafeCopy :: Mutable Vector s (Last a) -> Vector (Last a) -> ST s () # elemseq :: Vector (Last a) -> Last a -> b -> b #
Unbox a => Vector Vector (Max a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Max a) -> ST s (Vector (Max a)) # basicUnsafeThaw :: Vector (Max a) -> ST s (Mutable Vector s (Max a)) # basicLength :: Vector (Max a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Max a) -> Vector (Max a) # basicUnsafeIndexM :: Vector (Max a) -> Int -> Box (Max a) # basicUnsafeCopy :: Mutable Vector s (Max a) -> Vector (Max a) -> ST s () # elemseq :: Vector (Max a) -> Max a -> b -> b #
Unbox a => Vector Vector (Min a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Min a) -> ST s (Vector (Min a)) # basicUnsafeThaw :: Vector (Min a) -> ST s (Mutable Vector s (Min a)) # basicLength :: Vector (Min a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Min a) -> Vector (Min a) # basicUnsafeIndexM :: Vector (Min a) -> Int -> Box (Min a) # basicUnsafeCopy :: Mutable Vector s (Min a) -> Vector (Min a) -> ST s () # elemseq :: Vector (Min a) -> Min a -> b -> b #
Unbox a => Vector Vector (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (WrappedMonoid a) -> ST s (Vector (WrappedMonoid a)) # basicUnsafeThaw :: Vector (WrappedMonoid a) -> ST s (Mutable Vector s (WrappedMonoid a)) # basicLength :: Vector (WrappedMonoid a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (WrappedMonoid a) -> Vector (WrappedMonoid a) # basicUnsafeIndexM :: Vector (WrappedMonoid a) -> Int -> Box (WrappedMonoid a) # basicUnsafeCopy :: Mutable Vector s (WrappedMonoid a) -> Vector (WrappedMonoid a) -> ST s () # elemseq :: Vector (WrappedMonoid a) -> WrappedMonoid a -> b -> b #
Unbox a => Vector Vector (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Dual a) -> ST s (Vector (Dual a)) # basicUnsafeThaw :: Vector (Dual a) -> ST s (Mutable Vector s (Dual a)) # basicLength :: Vector (Dual a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Dual a) -> Vector (Dual a) # basicUnsafeIndexM :: Vector (Dual a) -> Int -> Box (Dual a) # basicUnsafeCopy :: Mutable Vector s (Dual a) -> Vector (Dual a) -> ST s () # elemseq :: Vector (Dual a) -> Dual a -> b -> b #
Unbox a => Vector Vector (Product a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Product a) -> ST s (Vector (Product a)) # basicUnsafeThaw :: Vector (Product a) -> ST s (Mutable Vector s (Product a)) # basicLength :: Vector (Product a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Product a) -> Vector (Product a) # basicUnsafeIndexM :: Vector (Product a) -> Int -> Box (Product a) # basicUnsafeCopy :: Mutable Vector s (Product a) -> Vector (Product a) -> ST s () # elemseq :: Vector (Product a) -> Product a -> b -> b #
Unbox a => Vector Vector (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Sum a) -> ST s (Vector (Sum a)) # basicUnsafeThaw :: Vector (Sum a) -> ST s (Mutable Vector s (Sum a)) # basicLength :: Vector (Sum a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Sum a) -> Vector (Sum a) # basicUnsafeIndexM :: Vector (Sum a) -> Int -> Box (Sum a) # basicUnsafeCopy :: Mutable Vector s (Sum a) -> Vector (Sum a) -> ST s () # elemseq :: Vector (Sum a) -> Sum a -> b -> b #
Vector Vector (DoNotUnboxLazy a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (DoNotUnboxLazy a) -> ST s (Vector (DoNotUnboxLazy a)) # basicUnsafeThaw :: Vector (DoNotUnboxLazy a) -> ST s (Mutable Vector s (DoNotUnboxLazy a)) # basicLength :: Vector (DoNotUnboxLazy a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxLazy a) -> Vector (DoNotUnboxLazy a) # basicUnsafeIndexM :: Vector (DoNotUnboxLazy a) -> Int -> Box (DoNotUnboxLazy a) # basicUnsafeCopy :: Mutable Vector s (DoNotUnboxLazy a) -> Vector (DoNotUnboxLazy a) -> ST s () # elemseq :: Vector (DoNotUnboxLazy a) -> DoNotUnboxLazy a -> b -> b #
NFData a => Vector Vector (DoNotUnboxNormalForm a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (DoNotUnboxNormalForm a) -> ST s (Vector (DoNotUnboxNormalForm a)) # basicUnsafeThaw :: Vector (DoNotUnboxNormalForm a) -> ST s (Mutable Vector s (DoNotUnboxNormalForm a)) # basicLength :: Vector (DoNotUnboxNormalForm a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxNormalForm a) -> Vector (DoNotUnboxNormalForm a) # basicUnsafeIndexM :: Vector (DoNotUnboxNormalForm a) -> Int -> Box (DoNotUnboxNormalForm a) # basicUnsafeCopy :: Mutable Vector s (DoNotUnboxNormalForm a) -> Vector (DoNotUnboxNormalForm a) -> ST s () # elemseq :: Vector (DoNotUnboxNormalForm a) -> DoNotUnboxNormalForm a -> b -> b #
Vector Vector (DoNotUnboxStrict a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (DoNotUnboxStrict a) -> ST s (Vector (DoNotUnboxStrict a)) # basicUnsafeThaw :: Vector (DoNotUnboxStrict a) -> ST s (Mutable Vector s (DoNotUnboxStrict a)) # basicLength :: Vector (DoNotUnboxStrict a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxStrict a) -> Vector (DoNotUnboxStrict a) # basicUnsafeIndexM :: Vector (DoNotUnboxStrict a) -> Int -> Box (DoNotUnboxStrict a) # basicUnsafeCopy :: Mutable Vector s (DoNotUnboxStrict a) -> Vector (DoNotUnboxStrict a) -> ST s () # elemseq :: Vector (DoNotUnboxStrict a) -> DoNotUnboxStrict a -> b -> b #
Prim a => Vector Vector (UnboxViaPrim a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (UnboxViaPrim a) -> ST s (Vector (UnboxViaPrim a)) # basicUnsafeThaw :: Vector (UnboxViaPrim a) -> ST s (Mutable Vector s (UnboxViaPrim a)) # basicLength :: Vector (UnboxViaPrim a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (UnboxViaPrim a) -> Vector (UnboxViaPrim a) # basicUnsafeIndexM :: Vector (UnboxViaPrim a) -> Int -> Box (UnboxViaPrim a) # basicUnsafeCopy :: Mutable Vector s (UnboxViaPrim a) -> Vector (UnboxViaPrim a) -> ST s () # elemseq :: Vector (UnboxViaPrim a) -> UnboxViaPrim a -> b -> b #
(Unbox a, Unbox b) => Vector Vector (Arg a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Arg a b) -> ST s (Vector (Arg a b)) # basicUnsafeThaw :: Vector (Arg a b) -> ST s (Mutable Vector s (Arg a b)) # basicLength :: Vector (Arg a b) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Arg a b) -> Vector (Arg a b) # basicUnsafeIndexM :: Vector (Arg a b) -> Int -> Box (Arg a b) # basicUnsafeCopy :: Mutable Vector s (Arg a b) -> Vector (Arg a b) -> ST s () # elemseq :: Vector (Arg a b) -> Arg a b -> b0 -> b0 #
(IsoUnbox a b, Unbox b) => Vector Vector (As a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (As a b) -> ST s (Vector (As a b)) # basicUnsafeThaw :: Vector (As a b) -> ST s (Mutable Vector s (As a b)) # basicLength :: Vector (As a b) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (As a b) -> Vector (As a b) # basicUnsafeIndexM :: Vector (As a b) -> Int -> Box (As a b) # basicUnsafeCopy :: Mutable Vector s (As a b) -> Vector (As a b) -> ST s () # elemseq :: Vector (As a b) -> As a b -> b0 -> b0 #
(Unbox a, Unbox b) => Vector Vector (a, b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (a, b) -> ST s (Vector (a, b)) # basicUnsafeThaw :: Vector (a, b) -> ST s (Mutable Vector s (a, b)) # basicLength :: Vector (a, b) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b) -> Vector (a, b) # basicUnsafeIndexM :: Vector (a, b) -> Int -> Box (a, b) # basicUnsafeCopy :: Mutable Vector s (a, b) -> Vector (a, b) -> ST s () # elemseq :: Vector (a, b) -> (a, b) -> b0 -> b0 #
Unbox a => Vector Vector (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Const a b) -> ST s (Vector (Const a b)) # basicUnsafeThaw :: Vector (Const a b) -> ST s (Mutable Vector s (Const a b)) # basicLength :: Vector (Const a b) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b) # basicUnsafeIndexM :: Vector (Const a b) -> Int -> Box (Const a b) # basicUnsafeCopy :: Mutable Vector s (Const a b) -> Vector (Const a b) -> ST s () # elemseq :: Vector (Const a b) -> Const a b -> b0 -> b0 #
Unbox (f a) => Vector Vector (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Alt f a) -> ST s (Vector (Alt f a)) # basicUnsafeThaw :: Vector (Alt f a) -> ST s (Mutable Vector s (Alt f a)) # basicLength :: Vector (Alt f a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Alt f a) -> Vector (Alt f a) # basicUnsafeIndexM :: Vector (Alt f a) -> Int -> Box (Alt f a) # basicUnsafeCopy :: Mutable Vector s (Alt f a) -> Vector (Alt f a) -> ST s () # elemseq :: Vector (Alt f a) -> Alt f a -> b -> b #
(Unbox a, Unbox b, Unbox c) => Vector Vector (a, b, c)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (a, b, c) -> ST s (Vector (a, b, c)) # basicUnsafeThaw :: Vector (a, b, c) -> ST s (Mutable Vector s (a, b, c)) # basicLength :: Vector (a, b, c) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c) -> Vector (a, b, c) # basicUnsafeIndexM :: Vector (a, b, c) -> Int -> Box (a, b, c) # basicUnsafeCopy :: Mutable Vector s (a, b, c) -> Vector (a, b, c) -> ST s () # elemseq :: Vector (a, b, c) -> (a, b, c) -> b0 -> b0 #
(Unbox a, Unbox b, Unbox c, Unbox d) => Vector Vector (a, b, c, d)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (a, b, c, d) -> ST s (Vector (a, b, c, d)) # basicUnsafeThaw :: Vector (a, b, c, d) -> ST s (Mutable Vector s (a, b, c, d)) # basicLength :: Vector (a, b, c, d) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d) -> Vector (a, b, c, d) # basicUnsafeIndexM :: Vector (a, b, c, d) -> Int -> Box (a, b, c, d) # basicUnsafeCopy :: Mutable Vector s (a, b, c, d) -> Vector (a, b, c, d) -> ST s () # elemseq :: Vector (a, b, c, d) -> (a, b, c, d) -> b0 -> b0 #
Unbox (f (g a)) => Vector Vector (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (Compose f g a) -> ST s (Vector (Compose f g a)) # basicUnsafeThaw :: Vector (Compose f g a) -> ST s (Mutable Vector s (Compose f g a)) # basicLength :: Vector (Compose f g a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Compose f g a) -> Vector (Compose f g a) # basicUnsafeIndexM :: Vector (Compose f g a) -> Int -> Box (Compose f g a) # basicUnsafeCopy :: Mutable Vector s (Compose f g a) -> Vector (Compose f g a) -> ST s () # elemseq :: Vector (Compose f g a) -> Compose f g a -> b -> b #
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector Vector (a, b, c, d, e)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (a, b, c, d, e) -> ST s (Vector (a, b, c, d, e)) # basicUnsafeThaw :: Vector (a, b, c, d, e) -> ST s (Mutable Vector s (a, b, c, d, e)) # basicLength :: Vector (a, b, c, d, e) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e) -> Vector (a, b, c, d, e) # basicUnsafeIndexM :: Vector (a, b, c, d, e) -> Int -> Box (a, b, c, d, e) # basicUnsafeCopy :: Mutable Vector s (a, b, c, d, e) -> Vector (a, b, c, d, e) -> ST s () # elemseq :: Vector (a, b, c, d, e) -> (a, b, c, d, e) -> b0 -> b0 #
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector Vector (a, b, c, d, e, f)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (a, b, c, d, e, f) -> ST s (Vector (a, b, c, d, e, f)) # basicUnsafeThaw :: Vector (a, b, c, d, e, f) -> ST s (Mutable Vector s (a, b, c, d, e, f)) # basicLength :: Vector (a, b, c, d, e, f) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) # basicUnsafeIndexM :: Vector (a, b, c, d, e, f) -> Int -> Box (a, b, c, d, e, f) # basicUnsafeCopy :: Mutable Vector s (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> ST s () # elemseq :: Vector (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> b0 -> b0 #
(Data a, Unbox a) => Data (Vector a)
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) # 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) #
NFData (Vector a)
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: Vector a -> () #
type Mutable Vector
Instance details Defined in Data.Vector.Unboxed.Base type Mutable Vector = MVector
newtype Vector All
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector All = V_All (Vector Bool)
newtype Vector Any
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Any = V_Any (Vector Bool)
newtype Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int16 = V_Int16 (Vector Int16)
newtype Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int32 = V_Int32 (Vector Int32)
newtype Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int64 = V_Int64 (Vector Int64)
newtype Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int8 = V_Int8 (Vector Int8)
newtype Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word16 = V_Word16 (Vector Word16)
newtype Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word32 = V_Word32 (Vector Word32)
newtype Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word64 = V_Word64 (Vector Word64)
newtype Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word8 = V_Word8 (Vector Word8)
newtype Vector ()
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector () = V_Unit Int
newtype Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Bool = V_Bool (Vector Word8)
newtype Vector Char
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Char = V_Char (Vector Char)
newtype Vector Double
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Double = V_Double (Vector Double)
newtype Vector Float
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Float = V_Float (Vector Float)
newtype Vector Int
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int = V_Int (Vector Int)
newtype Vector Word
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word = V_Word (Vector Word)
type Item (Vector e)
Instance details Defined in Data.Vector.Unboxed type Item (Vector e) = e
newtype Vector (Complex a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Complex a) = V_Complex (Vector (a, a))
newtype Vector (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Identity a) = V_Identity (Vector a)
newtype Vector (Down a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Down a) = V_Down (Vector a)
newtype Vector (First a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (First a) = V_First (Vector a)
newtype Vector (Last a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Last a) = V_Last (Vector a)
newtype Vector (Max a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Max a) = V_Max (Vector a)
newtype Vector (Min a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Min a) = V_Min (Vector a)
newtype Vector (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (WrappedMonoid a) = V_WrappedMonoid (Vector a)
newtype Vector (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Dual a) = V_Dual (Vector a)
newtype Vector (Product a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Product a) = V_Product (Vector a)
newtype Vector (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Sum a) = V_Sum (Vector a)
newtype Vector (DoNotUnboxLazy a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (DoNotUnboxLazy a) = V_DoNotUnboxLazy (Vector a)
newtype Vector (DoNotUnboxNormalForm a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (DoNotUnboxNormalForm a) = V_DoNotUnboxNormalForm (Vector a)
newtype Vector (DoNotUnboxStrict a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (DoNotUnboxStrict a) = V_DoNotUnboxStrict (Vector a)
newtype Vector (UnboxViaPrim a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (UnboxViaPrim a) = V_UnboxViaPrim (Vector a)
newtype Vector (Arg a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Arg a b) = V_Arg (Vector (a, b))
newtype Vector (As a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (As a b) = V_UnboxAs (Vector b)
data Vector (a, b)
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b) = V_2 !Int !(Vector a) !(Vector b)
newtype Vector (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Const a b) = V_Const (Vector a)
newtype Vector (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Alt f a) = V_Alt (Vector (f a))
data Vector (a, b, c)
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b, c) = V_3 !Int !(Vector a) !(Vector b) !(Vector c)
data Vector (a, b, c, d)
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)
newtype Vector (Compose f g a)
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)
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)
data Vector (a, b, c, d, e, f)
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)

convert :: (Vector v a, Vector w a) => v a -> w 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 #

backpermute :: Unbox a => Vector a -> Vector Int -> Vector a #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 #

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 #

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 #

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

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

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

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

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

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

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

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

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

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

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 #

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 #

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

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

spanR :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, 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 #

unsafeBackpermute :: Unbox a => Vector a -> Vector Int -> Vector a #

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

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

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

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

unsafeSlice :: Unbox a => Int -> 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 #

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

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

data family MVector s a #

Instances

Instances details

MVector MVector All
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s All -> Int # basicUnsafeSlice :: Int -> Int -> MVector s All -> MVector s All # basicOverlaps :: MVector s All -> MVector s All -> Bool # basicUnsafeNew :: Int -> ST s (MVector s All) # basicInitialize :: MVector s All -> ST s () # basicUnsafeReplicate :: Int -> All -> ST s (MVector s All) # basicUnsafeRead :: MVector s All -> Int -> ST s All # basicUnsafeWrite :: MVector s All -> Int -> All -> ST s () # basicClear :: MVector s All -> ST s () # basicSet :: MVector s All -> All -> ST s () # basicUnsafeCopy :: MVector s All -> MVector s All -> ST s () # basicUnsafeMove :: MVector s All -> MVector s All -> ST s () # basicUnsafeGrow :: MVector s All -> Int -> ST s (MVector s All) #
MVector MVector Any
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Any -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Any -> MVector s Any # basicOverlaps :: MVector s Any -> MVector s Any -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Any) # basicInitialize :: MVector s Any -> ST s () # basicUnsafeReplicate :: Int -> Any -> ST s (MVector s Any) # basicUnsafeRead :: MVector s Any -> Int -> ST s Any # basicUnsafeWrite :: MVector s Any -> Int -> Any -> ST s () # basicClear :: MVector s Any -> ST s () # basicSet :: MVector s Any -> Any -> ST s () # basicUnsafeCopy :: MVector s Any -> MVector s Any -> ST s () # basicUnsafeMove :: MVector s Any -> MVector s Any -> ST s () # basicUnsafeGrow :: MVector s Any -> Int -> ST s (MVector s Any) #
MVector MVector Int16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int16 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int16 -> MVector s Int16 # basicOverlaps :: MVector s Int16 -> MVector s Int16 -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Int16) # basicInitialize :: MVector s Int16 -> ST s () # basicUnsafeReplicate :: Int -> Int16 -> ST s (MVector s Int16) # basicUnsafeRead :: MVector s Int16 -> Int -> ST s Int16 # basicUnsafeWrite :: MVector s Int16 -> Int -> Int16 -> ST s () # basicClear :: MVector s Int16 -> ST s () # basicSet :: MVector s Int16 -> Int16 -> ST s () # basicUnsafeCopy :: MVector s Int16 -> MVector s Int16 -> ST s () # basicUnsafeMove :: MVector s Int16 -> MVector s Int16 -> ST s () # basicUnsafeGrow :: MVector s Int16 -> Int -> ST s (MVector s Int16) #
MVector MVector Int32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int32 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int32 -> MVector s Int32 # basicOverlaps :: MVector s Int32 -> MVector s Int32 -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Int32) # basicInitialize :: MVector s Int32 -> ST s () # basicUnsafeReplicate :: Int -> Int32 -> ST s (MVector s Int32) # basicUnsafeRead :: MVector s Int32 -> Int -> ST s Int32 # basicUnsafeWrite :: MVector s Int32 -> Int -> Int32 -> ST s () # basicClear :: MVector s Int32 -> ST s () # basicSet :: MVector s Int32 -> Int32 -> ST s () # basicUnsafeCopy :: MVector s Int32 -> MVector s Int32 -> ST s () # basicUnsafeMove :: MVector s Int32 -> MVector s Int32 -> ST s () # basicUnsafeGrow :: MVector s Int32 -> Int -> ST s (MVector s Int32) #
MVector MVector Int64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int64 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64 # basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Int64) # basicInitialize :: MVector s Int64 -> ST s () # basicUnsafeReplicate :: Int -> Int64 -> ST s (MVector s Int64) # basicUnsafeRead :: MVector s Int64 -> Int -> ST s Int64 # basicUnsafeWrite :: MVector s Int64 -> Int -> Int64 -> ST s () # basicClear :: MVector s Int64 -> ST s () # basicSet :: MVector s Int64 -> Int64 -> ST s () # basicUnsafeCopy :: MVector s Int64 -> MVector s Int64 -> ST s () # basicUnsafeMove :: MVector s Int64 -> MVector s Int64 -> ST s () # basicUnsafeGrow :: MVector s Int64 -> Int -> ST s (MVector s Int64) #
MVector MVector Int8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int8 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int8 -> MVector s Int8 # basicOverlaps :: MVector s Int8 -> MVector s Int8 -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Int8) # basicInitialize :: MVector s Int8 -> ST s () # basicUnsafeReplicate :: Int -> Int8 -> ST s (MVector s Int8) # basicUnsafeRead :: MVector s Int8 -> Int -> ST s Int8 # basicUnsafeWrite :: MVector s Int8 -> Int -> Int8 -> ST s () # basicClear :: MVector s Int8 -> ST s () # basicSet :: MVector s Int8 -> Int8 -> ST s () # basicUnsafeCopy :: MVector s Int8 -> MVector s Int8 -> ST s () # basicUnsafeMove :: MVector s Int8 -> MVector s Int8 -> ST s () # basicUnsafeGrow :: MVector s Int8 -> Int -> ST s (MVector s Int8) #
MVector MVector Word16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word16 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word16 -> MVector s Word16 # basicOverlaps :: MVector s Word16 -> MVector s Word16 -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Word16) # basicInitialize :: MVector s Word16 -> ST s () # basicUnsafeReplicate :: Int -> Word16 -> ST s (MVector s Word16) # basicUnsafeRead :: MVector s Word16 -> Int -> ST s Word16 # basicUnsafeWrite :: MVector s Word16 -> Int -> Word16 -> ST s () # basicClear :: MVector s Word16 -> ST s () # basicSet :: MVector s Word16 -> Word16 -> ST s () # basicUnsafeCopy :: MVector s Word16 -> MVector s Word16 -> ST s () # basicUnsafeMove :: MVector s Word16 -> MVector s Word16 -> ST s () # basicUnsafeGrow :: MVector s Word16 -> Int -> ST s (MVector s Word16) #
MVector MVector Word32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word32 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word32 -> MVector s Word32 # basicOverlaps :: MVector s Word32 -> MVector s Word32 -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Word32) # basicInitialize :: MVector s Word32 -> ST s () # basicUnsafeReplicate :: Int -> Word32 -> ST s (MVector s Word32) # basicUnsafeRead :: MVector s Word32 -> Int -> ST s Word32 # basicUnsafeWrite :: MVector s Word32 -> Int -> Word32 -> ST s () # basicClear :: MVector s Word32 -> ST s () # basicSet :: MVector s Word32 -> Word32 -> ST s () # basicUnsafeCopy :: MVector s Word32 -> MVector s Word32 -> ST s () # basicUnsafeMove :: MVector s Word32 -> MVector s Word32 -> ST s () # basicUnsafeGrow :: MVector s Word32 -> Int -> ST s (MVector s Word32) #
MVector MVector Word64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word64 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word64 -> MVector s Word64 # basicOverlaps :: MVector s Word64 -> MVector s Word64 -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Word64) # basicInitialize :: MVector s Word64 -> ST s () # basicUnsafeReplicate :: Int -> Word64 -> ST s (MVector s Word64) # basicUnsafeRead :: MVector s Word64 -> Int -> ST s Word64 # basicUnsafeWrite :: MVector s Word64 -> Int -> Word64 -> ST s () # basicClear :: MVector s Word64 -> ST s () # basicSet :: MVector s Word64 -> Word64 -> ST s () # basicUnsafeCopy :: MVector s Word64 -> MVector s Word64 -> ST s () # basicUnsafeMove :: MVector s Word64 -> MVector s Word64 -> ST s () # basicUnsafeGrow :: MVector s Word64 -> Int -> ST s (MVector s Word64) #
MVector MVector Word8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word8 -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8 # basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Word8) # basicInitialize :: MVector s Word8 -> ST s () # basicUnsafeReplicate :: Int -> Word8 -> ST s (MVector s Word8) # basicUnsafeRead :: MVector s Word8 -> Int -> ST s Word8 # basicUnsafeWrite :: MVector s Word8 -> Int -> Word8 -> ST s () # basicClear :: MVector s Word8 -> ST s () # basicSet :: MVector s Word8 -> Word8 -> ST s () # basicUnsafeCopy :: MVector s Word8 -> MVector s Word8 -> ST s () # basicUnsafeMove :: MVector s Word8 -> MVector s Word8 -> ST s () # basicUnsafeGrow :: MVector s Word8 -> Int -> ST s (MVector s Word8) #
MVector MVector ()
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s () -> Int # basicUnsafeSlice :: Int -> Int -> MVector s () -> MVector s () # basicOverlaps :: MVector s () -> MVector s () -> Bool # basicUnsafeNew :: Int -> ST s (MVector s ()) # basicInitialize :: MVector s () -> ST s () # basicUnsafeReplicate :: Int -> () -> ST s (MVector s ()) # basicUnsafeRead :: MVector s () -> Int -> ST s () # basicUnsafeWrite :: MVector s () -> Int -> () -> ST s () # basicClear :: MVector s () -> ST s () # basicSet :: MVector s () -> () -> ST s () # basicUnsafeCopy :: MVector s () -> MVector s () -> ST s () # basicUnsafeMove :: MVector s () -> MVector s () -> ST s () # basicUnsafeGrow :: MVector s () -> Int -> ST s (MVector s ()) #
MVector MVector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Bool -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool # basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Bool) # basicInitialize :: MVector s Bool -> ST s () # basicUnsafeReplicate :: Int -> Bool -> ST s (MVector s Bool) # basicUnsafeRead :: MVector s Bool -> Int -> ST s Bool # basicUnsafeWrite :: MVector s Bool -> Int -> Bool -> ST s () # basicClear :: MVector s Bool -> ST s () # basicSet :: MVector s Bool -> Bool -> ST s () # basicUnsafeCopy :: MVector s Bool -> MVector s Bool -> ST s () # basicUnsafeMove :: MVector s Bool -> MVector s Bool -> ST s () # basicUnsafeGrow :: MVector s Bool -> Int -> ST s (MVector s Bool) #
MVector MVector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Char -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char # basicOverlaps :: MVector s Char -> MVector s Char -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Char) # basicInitialize :: MVector s Char -> ST s () # basicUnsafeReplicate :: Int -> Char -> ST s (MVector s Char) # basicUnsafeRead :: MVector s Char -> Int -> ST s Char # basicUnsafeWrite :: MVector s Char -> Int -> Char -> ST s () # basicClear :: MVector s Char -> ST s () # basicSet :: MVector s Char -> Char -> ST s () # basicUnsafeCopy :: MVector s Char -> MVector s Char -> ST s () # basicUnsafeMove :: MVector s Char -> MVector s Char -> ST s () # basicUnsafeGrow :: MVector s Char -> Int -> ST s (MVector s Char) #
MVector MVector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Double -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double # basicOverlaps :: MVector s Double -> MVector s Double -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Double) # basicInitialize :: MVector s Double -> ST s () # basicUnsafeReplicate :: Int -> Double -> ST s (MVector s Double) # basicUnsafeRead :: MVector s Double -> Int -> ST s Double # basicUnsafeWrite :: MVector s Double -> Int -> Double -> ST s () # basicClear :: MVector s Double -> ST s () # basicSet :: MVector s Double -> Double -> ST s () # basicUnsafeCopy :: MVector s Double -> MVector s Double -> ST s () # basicUnsafeMove :: MVector s Double -> MVector s Double -> ST s () # basicUnsafeGrow :: MVector s Double -> Int -> ST s (MVector s Double) #
MVector MVector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Float -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float # basicOverlaps :: MVector s Float -> MVector s Float -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Float) # basicInitialize :: MVector s Float -> ST s () # basicUnsafeReplicate :: Int -> Float -> ST s (MVector s Float) # basicUnsafeRead :: MVector s Float -> Int -> ST s Float # basicUnsafeWrite :: MVector s Float -> Int -> Float -> ST s () # basicClear :: MVector s Float -> ST s () # basicSet :: MVector s Float -> Float -> ST s () # basicUnsafeCopy :: MVector s Float -> MVector s Float -> ST s () # basicUnsafeMove :: MVector s Float -> MVector s Float -> ST s () # basicUnsafeGrow :: MVector s Float -> Int -> ST s (MVector s Float) #
MVector MVector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int # basicOverlaps :: MVector s Int -> MVector s Int -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Int) # basicInitialize :: MVector s Int -> ST s () # basicUnsafeReplicate :: Int -> Int -> ST s (MVector s Int) # basicUnsafeRead :: MVector s Int -> Int -> ST s Int # basicUnsafeWrite :: MVector s Int -> Int -> Int -> ST s () # basicClear :: MVector s Int -> ST s () # basicSet :: MVector s Int -> Int -> ST s () # basicUnsafeCopy :: MVector s Int -> MVector s Int -> ST s () # basicUnsafeMove :: MVector s Int -> MVector s Int -> ST s () # basicUnsafeGrow :: MVector s Int -> Int -> ST s (MVector s Int) #
MVector MVector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word # basicOverlaps :: MVector s Word -> MVector s Word -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Word) # basicInitialize :: MVector s Word -> ST s () # basicUnsafeReplicate :: Int -> Word -> ST s (MVector s Word) # basicUnsafeRead :: MVector s Word -> Int -> ST s Word # basicUnsafeWrite :: MVector s Word -> Int -> Word -> ST s () # basicClear :: MVector s Word -> ST s () # basicSet :: MVector s Word -> Word -> ST s () # basicUnsafeCopy :: MVector s Word -> MVector s Word -> ST s () # basicUnsafeMove :: MVector s Word -> MVector s Word -> ST s () # basicUnsafeGrow :: MVector s Word -> Int -> ST s (MVector s Word) #
Unbox a => MVector MVector (Complex a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Complex a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Complex a) -> MVector s (Complex a) # basicOverlaps :: MVector s (Complex a) -> MVector s (Complex a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Complex a)) # basicInitialize :: MVector s (Complex a) -> ST s () # basicUnsafeReplicate :: Int -> Complex a -> ST s (MVector s (Complex a)) # basicUnsafeRead :: MVector s (Complex a) -> Int -> ST s (Complex a) # basicUnsafeWrite :: MVector s (Complex a) -> Int -> Complex a -> ST s () # basicClear :: MVector s (Complex a) -> ST s () # basicSet :: MVector s (Complex a) -> Complex a -> ST s () # basicUnsafeCopy :: MVector s (Complex a) -> MVector s (Complex a) -> ST s () # basicUnsafeMove :: MVector s (Complex a) -> MVector s (Complex a) -> ST s () # basicUnsafeGrow :: MVector s (Complex a) -> Int -> ST s (MVector s (Complex a)) #
Unbox a => MVector MVector (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Identity a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Identity a) -> MVector s (Identity a) # basicOverlaps :: MVector s (Identity a) -> MVector s (Identity a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Identity a)) # basicInitialize :: MVector s (Identity a) -> ST s () # basicUnsafeReplicate :: Int -> Identity a -> ST s (MVector s (Identity a)) # basicUnsafeRead :: MVector s (Identity a) -> Int -> ST s (Identity a) # basicUnsafeWrite :: MVector s (Identity a) -> Int -> Identity a -> ST s () # basicClear :: MVector s (Identity a) -> ST s () # basicSet :: MVector s (Identity a) -> Identity a -> ST s () # basicUnsafeCopy :: MVector s (Identity a) -> MVector s (Identity a) -> ST s () # basicUnsafeMove :: MVector s (Identity a) -> MVector s (Identity a) -> ST s () # basicUnsafeGrow :: MVector s (Identity a) -> Int -> ST s (MVector s (Identity a)) #
Unbox a => MVector MVector (Down a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Down a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Down a) -> MVector s (Down a) # basicOverlaps :: MVector s (Down a) -> MVector s (Down a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Down a)) # basicInitialize :: MVector s (Down a) -> ST s () # basicUnsafeReplicate :: Int -> Down a -> ST s (MVector s (Down a)) # basicUnsafeRead :: MVector s (Down a) -> Int -> ST s (Down a) # basicUnsafeWrite :: MVector s (Down a) -> Int -> Down a -> ST s () # basicClear :: MVector s (Down a) -> ST s () # basicSet :: MVector s (Down a) -> Down a -> ST s () # basicUnsafeCopy :: MVector s (Down a) -> MVector s (Down a) -> ST s () # basicUnsafeMove :: MVector s (Down a) -> MVector s (Down a) -> ST s () # basicUnsafeGrow :: MVector s (Down a) -> Int -> ST s (MVector s (Down a)) #
Unbox a => MVector MVector (First a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (First a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (First a) -> MVector s (First a) # basicOverlaps :: MVector s (First a) -> MVector s (First a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (First a)) # basicInitialize :: MVector s (First a) -> ST s () # basicUnsafeReplicate :: Int -> First a -> ST s (MVector s (First a)) # basicUnsafeRead :: MVector s (First a) -> Int -> ST s (First a) # basicUnsafeWrite :: MVector s (First a) -> Int -> First a -> ST s () # basicClear :: MVector s (First a) -> ST s () # basicSet :: MVector s (First a) -> First a -> ST s () # basicUnsafeCopy :: MVector s (First a) -> MVector s (First a) -> ST s () # basicUnsafeMove :: MVector s (First a) -> MVector s (First a) -> ST s () # basicUnsafeGrow :: MVector s (First a) -> Int -> ST s (MVector s (First a)) #
Unbox a => MVector MVector (Last a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Last a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Last a) -> MVector s (Last a) # basicOverlaps :: MVector s (Last a) -> MVector s (Last a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Last a)) # basicInitialize :: MVector s (Last a) -> ST s () # basicUnsafeReplicate :: Int -> Last a -> ST s (MVector s (Last a)) # basicUnsafeRead :: MVector s (Last a) -> Int -> ST s (Last a) # basicUnsafeWrite :: MVector s (Last a) -> Int -> Last a -> ST s () # basicClear :: MVector s (Last a) -> ST s () # basicSet :: MVector s (Last a) -> Last a -> ST s () # basicUnsafeCopy :: MVector s (Last a) -> MVector s (Last a) -> ST s () # basicUnsafeMove :: MVector s (Last a) -> MVector s (Last a) -> ST s () # basicUnsafeGrow :: MVector s (Last a) -> Int -> ST s (MVector s (Last a)) #
Unbox a => MVector MVector (Max a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Max a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Max a) -> MVector s (Max a) # basicOverlaps :: MVector s (Max a) -> MVector s (Max a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Max a)) # basicInitialize :: MVector s (Max a) -> ST s () # basicUnsafeReplicate :: Int -> Max a -> ST s (MVector s (Max a)) # basicUnsafeRead :: MVector s (Max a) -> Int -> ST s (Max a) # basicUnsafeWrite :: MVector s (Max a) -> Int -> Max a -> ST s () # basicClear :: MVector s (Max a) -> ST s () # basicSet :: MVector s (Max a) -> Max a -> ST s () # basicUnsafeCopy :: MVector s (Max a) -> MVector s (Max a) -> ST s () # basicUnsafeMove :: MVector s (Max a) -> MVector s (Max a) -> ST s () # basicUnsafeGrow :: MVector s (Max a) -> Int -> ST s (MVector s (Max a)) #
Unbox a => MVector MVector (Min a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Min a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Min a) -> MVector s (Min a) # basicOverlaps :: MVector s (Min a) -> MVector s (Min a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Min a)) # basicInitialize :: MVector s (Min a) -> ST s () # basicUnsafeReplicate :: Int -> Min a -> ST s (MVector s (Min a)) # basicUnsafeRead :: MVector s (Min a) -> Int -> ST s (Min a) # basicUnsafeWrite :: MVector s (Min a) -> Int -> Min a -> ST s () # basicClear :: MVector s (Min a) -> ST s () # basicSet :: MVector s (Min a) -> Min a -> ST s () # basicUnsafeCopy :: MVector s (Min a) -> MVector s (Min a) -> ST s () # basicUnsafeMove :: MVector s (Min a) -> MVector s (Min a) -> ST s () # basicUnsafeGrow :: MVector s (Min a) -> Int -> ST s (MVector s (Min a)) #
Unbox a => MVector MVector (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (WrappedMonoid a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) # basicOverlaps :: MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (WrappedMonoid a)) # basicInitialize :: MVector s (WrappedMonoid a) -> ST s () # basicUnsafeReplicate :: Int -> WrappedMonoid a -> ST s (MVector s (WrappedMonoid a)) # basicUnsafeRead :: MVector s (WrappedMonoid a) -> Int -> ST s (WrappedMonoid a) # basicUnsafeWrite :: MVector s (WrappedMonoid a) -> Int -> WrappedMonoid a -> ST s () # basicClear :: MVector s (WrappedMonoid a) -> ST s () # basicSet :: MVector s (WrappedMonoid a) -> WrappedMonoid a -> ST s () # basicUnsafeCopy :: MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) -> ST s () # basicUnsafeMove :: MVector s (WrappedMonoid a) -> MVector s (WrappedMonoid a) -> ST s () # basicUnsafeGrow :: MVector s (WrappedMonoid a) -> Int -> ST s (MVector s (WrappedMonoid a)) #
Unbox a => MVector MVector (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Dual a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Dual a) -> MVector s (Dual a) # basicOverlaps :: MVector s (Dual a) -> MVector s (Dual a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Dual a)) # basicInitialize :: MVector s (Dual a) -> ST s () # basicUnsafeReplicate :: Int -> Dual a -> ST s (MVector s (Dual a)) # basicUnsafeRead :: MVector s (Dual a) -> Int -> ST s (Dual a) # basicUnsafeWrite :: MVector s (Dual a) -> Int -> Dual a -> ST s () # basicClear :: MVector s (Dual a) -> ST s () # basicSet :: MVector s (Dual a) -> Dual a -> ST s () # basicUnsafeCopy :: MVector s (Dual a) -> MVector s (Dual a) -> ST s () # basicUnsafeMove :: MVector s (Dual a) -> MVector s (Dual a) -> ST s () # basicUnsafeGrow :: MVector s (Dual a) -> Int -> ST s (MVector s (Dual a)) #
Unbox a => MVector MVector (Product a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Product a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Product a) -> MVector s (Product a) # basicOverlaps :: MVector s (Product a) -> MVector s (Product a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Product a)) # basicInitialize :: MVector s (Product a) -> ST s () # basicUnsafeReplicate :: Int -> Product a -> ST s (MVector s (Product a)) # basicUnsafeRead :: MVector s (Product a) -> Int -> ST s (Product a) # basicUnsafeWrite :: MVector s (Product a) -> Int -> Product a -> ST s () # basicClear :: MVector s (Product a) -> ST s () # basicSet :: MVector s (Product a) -> Product a -> ST s () # basicUnsafeCopy :: MVector s (Product a) -> MVector s (Product a) -> ST s () # basicUnsafeMove :: MVector s (Product a) -> MVector s (Product a) -> ST s () # basicUnsafeGrow :: MVector s (Product a) -> Int -> ST s (MVector s (Product a)) #
Unbox a => MVector MVector (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Sum a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Sum a) -> MVector s (Sum a) # basicOverlaps :: MVector s (Sum a) -> MVector s (Sum a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Sum a)) # basicInitialize :: MVector s (Sum a) -> ST s () # basicUnsafeReplicate :: Int -> Sum a -> ST s (MVector s (Sum a)) # basicUnsafeRead :: MVector s (Sum a) -> Int -> ST s (Sum a) # basicUnsafeWrite :: MVector s (Sum a) -> Int -> Sum a -> ST s () # basicClear :: MVector s (Sum a) -> ST s () # basicSet :: MVector s (Sum a) -> Sum a -> ST s () # basicUnsafeCopy :: MVector s (Sum a) -> MVector s (Sum a) -> ST s () # basicUnsafeMove :: MVector s (Sum a) -> MVector s (Sum a) -> ST s () # basicUnsafeGrow :: MVector s (Sum a) -> Int -> ST s (MVector s (Sum a)) #
MVector MVector (DoNotUnboxLazy a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (DoNotUnboxLazy a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a) # basicOverlaps :: MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (DoNotUnboxLazy a)) # basicInitialize :: MVector s (DoNotUnboxLazy a) -> ST s () # basicUnsafeReplicate :: Int -> DoNotUnboxLazy a -> ST s (MVector s (DoNotUnboxLazy a)) # basicUnsafeRead :: MVector s (DoNotUnboxLazy a) -> Int -> ST s (DoNotUnboxLazy a) # basicUnsafeWrite :: MVector s (DoNotUnboxLazy a) -> Int -> DoNotUnboxLazy a -> ST s () # basicClear :: MVector s (DoNotUnboxLazy a) -> ST s () # basicSet :: MVector s (DoNotUnboxLazy a) -> DoNotUnboxLazy a -> ST s () # basicUnsafeCopy :: MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a) -> ST s () # basicUnsafeMove :: MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a) -> ST s () # basicUnsafeGrow :: MVector s (DoNotUnboxLazy a) -> Int -> ST s (MVector s (DoNotUnboxLazy a)) #
NFData a => MVector MVector (DoNotUnboxNormalForm a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (DoNotUnboxNormalForm a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a) # basicOverlaps :: MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (DoNotUnboxNormalForm a)) # basicInitialize :: MVector s (DoNotUnboxNormalForm a) -> ST s () # basicUnsafeReplicate :: Int -> DoNotUnboxNormalForm a -> ST s (MVector s (DoNotUnboxNormalForm a)) # basicUnsafeRead :: MVector s (DoNotUnboxNormalForm a) -> Int -> ST s (DoNotUnboxNormalForm a) # basicUnsafeWrite :: MVector s (DoNotUnboxNormalForm a) -> Int -> DoNotUnboxNormalForm a -> ST s () # basicClear :: MVector s (DoNotUnboxNormalForm a) -> ST s () # basicSet :: MVector s (DoNotUnboxNormalForm a) -> DoNotUnboxNormalForm a -> ST s () # basicUnsafeCopy :: MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a) -> ST s () # basicUnsafeMove :: MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a) -> ST s () # basicUnsafeGrow :: MVector s (DoNotUnboxNormalForm a) -> Int -> ST s (MVector s (DoNotUnboxNormalForm a)) #
MVector MVector (DoNotUnboxStrict a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (DoNotUnboxStrict a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a) # basicOverlaps :: MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (DoNotUnboxStrict a)) # basicInitialize :: MVector s (DoNotUnboxStrict a) -> ST s () # basicUnsafeReplicate :: Int -> DoNotUnboxStrict a -> ST s (MVector s (DoNotUnboxStrict a)) # basicUnsafeRead :: MVector s (DoNotUnboxStrict a) -> Int -> ST s (DoNotUnboxStrict a) # basicUnsafeWrite :: MVector s (DoNotUnboxStrict a) -> Int -> DoNotUnboxStrict a -> ST s () # basicClear :: MVector s (DoNotUnboxStrict a) -> ST s () # basicSet :: MVector s (DoNotUnboxStrict a) -> DoNotUnboxStrict a -> ST s () # basicUnsafeCopy :: MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a) -> ST s () # basicUnsafeMove :: MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a) -> ST s () # basicUnsafeGrow :: MVector s (DoNotUnboxStrict a) -> Int -> ST s (MVector s (DoNotUnboxStrict a)) #
Prim a => MVector MVector (UnboxViaPrim a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (UnboxViaPrim a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) # basicOverlaps :: MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (UnboxViaPrim a)) # basicInitialize :: MVector s (UnboxViaPrim a) -> ST s () # basicUnsafeReplicate :: Int -> UnboxViaPrim a -> ST s (MVector s (UnboxViaPrim a)) # basicUnsafeRead :: MVector s (UnboxViaPrim a) -> Int -> ST s (UnboxViaPrim a) # basicUnsafeWrite :: MVector s (UnboxViaPrim a) -> Int -> UnboxViaPrim a -> ST s () # basicClear :: MVector s (UnboxViaPrim a) -> ST s () # basicSet :: MVector s (UnboxViaPrim a) -> UnboxViaPrim a -> ST s () # basicUnsafeCopy :: MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) -> ST s () # basicUnsafeMove :: MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) -> ST s () # basicUnsafeGrow :: MVector s (UnboxViaPrim a) -> Int -> ST s (MVector s (UnboxViaPrim a)) #
(Unbox a, Unbox b) => MVector MVector (Arg a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Arg a b) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Arg a b) -> MVector s (Arg a b) # basicOverlaps :: MVector s (Arg a b) -> MVector s (Arg a b) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Arg a b)) # basicInitialize :: MVector s (Arg a b) -> ST s () # basicUnsafeReplicate :: Int -> Arg a b -> ST s (MVector s (Arg a b)) # basicUnsafeRead :: MVector s (Arg a b) -> Int -> ST s (Arg a b) # basicUnsafeWrite :: MVector s (Arg a b) -> Int -> Arg a b -> ST s () # basicClear :: MVector s (Arg a b) -> ST s () # basicSet :: MVector s (Arg a b) -> Arg a b -> ST s () # basicUnsafeCopy :: MVector s (Arg a b) -> MVector s (Arg a b) -> ST s () # basicUnsafeMove :: MVector s (Arg a b) -> MVector s (Arg a b) -> ST s () # basicUnsafeGrow :: MVector s (Arg a b) -> Int -> ST s (MVector s (Arg a b)) #
(IsoUnbox a b, Unbox b) => MVector MVector (As a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (As a b) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (As a b) -> MVector s (As a b) # basicOverlaps :: MVector s (As a b) -> MVector s (As a b) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (As a b)) # basicInitialize :: MVector s (As a b) -> ST s () # basicUnsafeReplicate :: Int -> As a b -> ST s (MVector s (As a b)) # basicUnsafeRead :: MVector s (As a b) -> Int -> ST s (As a b) # basicUnsafeWrite :: MVector s (As a b) -> Int -> As a b -> ST s () # basicClear :: MVector s (As a b) -> ST s () # basicSet :: MVector s (As a b) -> As a b -> ST s () # basicUnsafeCopy :: MVector s (As a b) -> MVector s (As a b) -> ST s () # basicUnsafeMove :: MVector s (As a b) -> MVector s (As a b) -> ST s () # basicUnsafeGrow :: MVector s (As a b) -> Int -> ST s (MVector s (As a b)) #
(Unbox a, Unbox b) => MVector MVector (a, b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (a, b) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (a, b) -> MVector s (a, b) # basicOverlaps :: MVector s (a, b) -> MVector s (a, b) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (a, b)) # basicInitialize :: MVector s (a, b) -> ST s () # basicUnsafeReplicate :: Int -> (a, b) -> ST s (MVector s (a, b)) # basicUnsafeRead :: MVector s (a, b) -> Int -> ST s (a, b) # basicUnsafeWrite :: MVector s (a, b) -> Int -> (a, b) -> ST s () # basicClear :: MVector s (a, b) -> ST s () # basicSet :: MVector s (a, b) -> (a, b) -> ST s () # basicUnsafeCopy :: MVector s (a, b) -> MVector s (a, b) -> ST s () # basicUnsafeMove :: MVector s (a, b) -> MVector s (a, b) -> ST s () # basicUnsafeGrow :: MVector s (a, b) -> Int -> ST s (MVector s (a, b)) #
Unbox a => MVector MVector (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Const a b) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Const a b) -> MVector s (Const a b) # basicOverlaps :: MVector s (Const a b) -> MVector s (Const a b) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Const a b)) # basicInitialize :: MVector s (Const a b) -> ST s () # basicUnsafeReplicate :: Int -> Const a b -> ST s (MVector s (Const a b)) # basicUnsafeRead :: MVector s (Const a b) -> Int -> ST s (Const a b) # basicUnsafeWrite :: MVector s (Const a b) -> Int -> Const a b -> ST s () # basicClear :: MVector s (Const a b) -> ST s () # basicSet :: MVector s (Const a b) -> Const a b -> ST s () # basicUnsafeCopy :: MVector s (Const a b) -> MVector s (Const a b) -> ST s () # basicUnsafeMove :: MVector s (Const a b) -> MVector s (Const a b) -> ST s () # basicUnsafeGrow :: MVector s (Const a b) -> Int -> ST s (MVector s (Const a b)) #
Unbox (f a) => MVector MVector (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Alt f a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Alt f a) -> MVector s (Alt f a) # basicOverlaps :: MVector s (Alt f a) -> MVector s (Alt f a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Alt f a)) # basicInitialize :: MVector s (Alt f a) -> ST s () # basicUnsafeReplicate :: Int -> Alt f a -> ST s (MVector s (Alt f a)) # basicUnsafeRead :: MVector s (Alt f a) -> Int -> ST s (Alt f a) # basicUnsafeWrite :: MVector s (Alt f a) -> Int -> Alt f a -> ST s () # basicClear :: MVector s (Alt f a) -> ST s () # basicSet :: MVector s (Alt f a) -> Alt f a -> ST s () # basicUnsafeCopy :: MVector s (Alt f a) -> MVector s (Alt f a) -> ST s () # basicUnsafeMove :: MVector s (Alt f a) -> MVector s (Alt f a) -> ST s () # basicUnsafeGrow :: MVector s (Alt f a) -> Int -> ST s (MVector s (Alt f a)) #
(Unbox a, Unbox b, Unbox c) => MVector MVector (a, b, c)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (a, b, c) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c) -> MVector s (a, b, c) # basicOverlaps :: MVector s (a, b, c) -> MVector s (a, b, c) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (a, b, c)) # basicInitialize :: MVector s (a, b, c) -> ST s () # basicUnsafeReplicate :: Int -> (a, b, c) -> ST s (MVector s (a, b, c)) # basicUnsafeRead :: MVector s (a, b, c) -> Int -> ST s (a, b, c) # basicUnsafeWrite :: MVector s (a, b, c) -> Int -> (a, b, c) -> ST s () # basicClear :: MVector s (a, b, c) -> ST s () # basicSet :: MVector s (a, b, c) -> (a, b, c) -> ST s () # basicUnsafeCopy :: MVector s (a, b, c) -> MVector s (a, b, c) -> ST s () # basicUnsafeMove :: MVector s (a, b, c) -> MVector s (a, b, c) -> ST s () # basicUnsafeGrow :: MVector s (a, b, c) -> Int -> ST s (MVector s (a, b, c)) #
(Unbox a, Unbox b, Unbox c, Unbox d) => MVector MVector (a, b, c, d)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (a, b, c, d) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d) -> MVector s (a, b, c, d) # basicOverlaps :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (a, b, c, d)) # basicInitialize :: MVector s (a, b, c, d) -> ST s () # basicUnsafeReplicate :: Int -> (a, b, c, d) -> ST s (MVector s (a, b, c, d)) # basicUnsafeRead :: MVector s (a, b, c, d) -> Int -> ST s (a, b, c, d) # basicUnsafeWrite :: MVector s (a, b, c, d) -> Int -> (a, b, c, d) -> ST s () # basicClear :: MVector s (a, b, c, d) -> ST s () # basicSet :: MVector s (a, b, c, d) -> (a, b, c, d) -> ST s () # basicUnsafeCopy :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> ST s () # basicUnsafeMove :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> ST s () # basicUnsafeGrow :: MVector s (a, b, c, d) -> Int -> ST s (MVector s (a, b, c, d)) #
Unbox (f (g a)) => MVector MVector (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (Compose f g a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Compose f g a) -> MVector s (Compose f g a) # basicOverlaps :: MVector s (Compose f g a) -> MVector s (Compose f g a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Compose f g a)) # basicInitialize :: MVector s (Compose f g a) -> ST s () # basicUnsafeReplicate :: Int -> Compose f g a -> ST s (MVector s (Compose f g a)) # basicUnsafeRead :: MVector s (Compose f g a) -> Int -> ST s (Compose f g a) # basicUnsafeWrite :: MVector s (Compose f g a) -> Int -> Compose f g a -> ST s () # basicClear :: MVector s (Compose f g a) -> ST s () # basicSet :: MVector s (Compose f g a) -> Compose f g a -> ST s () # basicUnsafeCopy :: MVector s (Compose f g a) -> MVector s (Compose f g a) -> ST s () # basicUnsafeMove :: MVector s (Compose f g a) -> MVector s (Compose f g a) -> ST s () # basicUnsafeGrow :: MVector s (Compose f g a) -> Int -> ST s (MVector s (Compose f g a)) #
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => MVector MVector (a, b, c, d, e)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (a, b, c, d, e) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) # basicOverlaps :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (a, b, c, d, e)) # basicInitialize :: MVector s (a, b, c, d, e) -> ST s () # basicUnsafeReplicate :: Int -> (a, b, c, d, e) -> ST s (MVector s (a, b, c, d, e)) # basicUnsafeRead :: MVector s (a, b, c, d, e) -> Int -> ST s (a, b, c, d, e) # basicUnsafeWrite :: MVector s (a, b, c, d, e) -> Int -> (a, b, c, d, e) -> ST s () # basicClear :: MVector s (a, b, c, d, e) -> ST s () # basicSet :: MVector s (a, b, c, d, e) -> (a, b, c, d, e) -> ST s () # basicUnsafeCopy :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> ST s () # basicUnsafeMove :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> ST s () # basicUnsafeGrow :: MVector s (a, b, c, d, e) -> Int -> ST s (MVector s (a, b, c, d, e)) #
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => MVector MVector (a, b, c, d, e, f)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (a, b, c, d, e, f) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) # basicOverlaps :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (a, b, c, d, e, f)) # basicInitialize :: MVector s (a, b, c, d, e, f) -> ST s () # basicUnsafeReplicate :: Int -> (a, b, c, d, e, f) -> ST s (MVector s (a, b, c, d, e, f)) # basicUnsafeRead :: MVector s (a, b, c, d, e, f) -> Int -> ST s (a, b, c, d, e, f) # basicUnsafeWrite :: MVector s (a, b, c, d, e, f) -> Int -> (a, b, c, d, e, f) -> ST s () # basicClear :: MVector s (a, b, c, d, e, f) -> ST s () # basicSet :: MVector s (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> ST s () # basicUnsafeCopy :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> ST s () # basicUnsafeMove :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> ST s () # basicUnsafeGrow :: MVector s (a, b, c, d, e, f) -> Int -> ST s (MVector s (a, b, c, d, e, f)) #
NFData1 (MVector s)
Instance details Defined in Data.Vector.Unboxed.Base Methods liftRnf :: (a -> ()) -> MVector s a -> () #
NFData (MVector s a)
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: MVector s a -> () #
newtype MVector s All
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s All = MV_All (MVector s Bool)
newtype MVector s Any
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Any = MV_Any (MVector s Bool)
newtype MVector s Int16
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int16 = MV_Int16 (MVector s Int16)
newtype MVector s Int32
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int32 = MV_Int32 (MVector s Int32)
newtype MVector s Int64
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int64 = MV_Int64 (MVector s Int64)
newtype MVector s Int8
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int8 = MV_Int8 (MVector s Int8)
newtype MVector s Word16
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word16 = MV_Word16 (MVector s Word16)
newtype MVector s Word32
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word32 = MV_Word32 (MVector s Word32)
newtype MVector s Word64
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word64 = MV_Word64 (MVector s Word64)
newtype MVector s Word8
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word8 = MV_Word8 (MVector s Word8)
newtype MVector s ()
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s () = MV_Unit Int
newtype MVector s Bool
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Bool = MV_Bool (MVector s Word8)
newtype MVector s Char
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Char = MV_Char (MVector s Char)
newtype MVector s Double
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Double = MV_Double (MVector s Double)
newtype MVector s Float
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Float = MV_Float (MVector s Float)
newtype MVector s Int
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int = MV_Int (MVector s Int)
newtype MVector s Word
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word = MV_Word (MVector s Word)
newtype MVector s (Complex a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Complex a) = MV_Complex (MVector s (a, a))
newtype MVector s (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Identity a) = MV_Identity (MVector s a)
newtype MVector s (Down a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Down a) = MV_Down (MVector s a)
newtype MVector s (First a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (First a) = MV_First (MVector s a)
newtype MVector s (Last a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Last a) = MV_Last (MVector s a)
newtype MVector s (Max a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Max a) = MV_Max (MVector s a)
newtype MVector s (Min a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Min a) = MV_Min (MVector s a)
newtype MVector s (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (WrappedMonoid a) = MV_WrappedMonoid (MVector s a)
newtype MVector s (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Dual a) = MV_Dual (MVector s a)
newtype MVector s (Product a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Product a) = MV_Product (MVector s a)
newtype MVector s (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Sum a) = MV_Sum (MVector s a)
newtype MVector s (DoNotUnboxLazy a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (DoNotUnboxLazy a) = MV_DoNotUnboxLazy (MVector s a)
newtype MVector s (DoNotUnboxNormalForm a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (DoNotUnboxNormalForm a) = MV_DoNotUnboxNormalForm (MVector s a)
newtype MVector s (DoNotUnboxStrict a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (DoNotUnboxStrict a) = MV_DoNotUnboxStrict (MVector s a)
newtype MVector s (UnboxViaPrim a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (UnboxViaPrim a) = MV_UnboxViaPrim (MVector s a)
newtype MVector s (Arg a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Arg a b) = MV_Arg (MVector s (a, b))
newtype MVector s (As a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (As a b) = MV_UnboxAs (MVector s b)
data MVector s (a, b)
Instance details Defined in Data.Vector.Unboxed.Base data MVector s (a, b) = MV_2 !Int !(MVector s a) !(MVector s b)
newtype MVector s (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Const a b) = MV_Const (MVector s a)
newtype MVector s (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Alt f a) = MV_Alt (MVector s (f a))
data MVector s (a, b, c)
Instance details Defined in Data.Vector.Unboxed.Base data MVector s (a, b, c) = MV_3 !Int !(MVector s a) !(MVector s b) !(MVector s c)
data MVector s (a, b, c, d)
Instance details Defined in Data.Vector.Unboxed.Base data MVector s (a, b, c, d) = MV_4 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d)
newtype MVector s (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Compose f g a) = MV_Compose (MVector s (f (g a)))
data MVector s (a, b, c, d, e)
Instance details Defined in Data.Vector.Unboxed.Base data MVector s (a, b, c, d, e) = MV_5 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d) !(MVector s e)
data MVector s (a, b, c, d, e, f)
Instance details Defined in Data.Vector.Unboxed.Base data MVector s (a, b, c, d, e, f) = MV_6 !Int !(MVector s a) !(MVector s b) !(MVector s c) !(MVector s d) !(MVector s e) !(MVector s f)

class (Vector Vector a, MVector MVector a) => Unbox a #

Instances

Instances details

Unbox All
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Any
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int16
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int32
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int64
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int8
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word16
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word32
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word64
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word8
Instance details Defined in Data.Vector.Unboxed.Base
Unbox ()
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Bool
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Char
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Double
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Float
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Complex a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Down a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (First a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Last a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Max a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Min a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Product a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox (DoNotUnboxLazy a)
Instance details Defined in Data.Vector.Unboxed.Base
NFData a => Unbox (DoNotUnboxNormalForm a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox (DoNotUnboxStrict a)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b) => Unbox (Arg a b)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b) => Unbox (a, b)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox (f a) => Unbox (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox (f (g a)) => Unbox (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Unbox (a, b, c, d, e)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Unbox (a, b, c, d, e, f)
Instance details Defined in Data.Vector.Unboxed.Base

newtype As a b #

Constructors

As a

Instances

Instances details

(IsoUnbox a b, Unbox b) => Vector Vector (As a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (As a b) -> ST s (Vector (As a b)) # basicUnsafeThaw :: Vector (As a b) -> ST s (Mutable Vector s (As a b)) # basicLength :: Vector (As a b) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (As a b) -> Vector (As a b) # basicUnsafeIndexM :: Vector (As a b) -> Int -> Box (As a b) # basicUnsafeCopy :: Mutable Vector s (As a b) -> Vector (As a b) -> ST s () # elemseq :: Vector (As a b) -> As a b -> b0 -> b0 #
(IsoUnbox a b, Unbox b) => MVector MVector (As a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (As a b) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (As a b) -> MVector s (As a b) # basicOverlaps :: MVector s (As a b) -> MVector s (As a b) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (As a b)) # basicInitialize :: MVector s (As a b) -> ST s () # basicUnsafeReplicate :: Int -> As a b -> ST s (MVector s (As a b)) # basicUnsafeRead :: MVector s (As a b) -> Int -> ST s (As a b) # basicUnsafeWrite :: MVector s (As a b) -> Int -> As a b -> ST s () # basicClear :: MVector s (As a b) -> ST s () # basicSet :: MVector s (As a b) -> As a b -> ST s () # basicUnsafeCopy :: MVector s (As a b) -> MVector s (As a b) -> ST s () # basicUnsafeMove :: MVector s (As a b) -> MVector s (As a b) -> ST s () # basicUnsafeGrow :: MVector s (As a b) -> Int -> ST s (MVector s (As a b)) #
newtype MVector s (As a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (As a b) = MV_UnboxAs (MVector s b)
newtype Vector (As a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (As a b) = V_UnboxAs (Vector b)

newtype DoNotUnboxLazy a #

Constructors

DoNotUnboxLazy a

Instances

Instances details

Vector Vector (DoNotUnboxLazy a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (DoNotUnboxLazy a) -> ST s (Vector (DoNotUnboxLazy a)) # basicUnsafeThaw :: Vector (DoNotUnboxLazy a) -> ST s (Mutable Vector s (DoNotUnboxLazy a)) # basicLength :: Vector (DoNotUnboxLazy a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxLazy a) -> Vector (DoNotUnboxLazy a) # basicUnsafeIndexM :: Vector (DoNotUnboxLazy a) -> Int -> Box (DoNotUnboxLazy a) # basicUnsafeCopy :: Mutable Vector s (DoNotUnboxLazy a) -> Vector (DoNotUnboxLazy a) -> ST s () # elemseq :: Vector (DoNotUnboxLazy a) -> DoNotUnboxLazy a -> b -> b #
MVector MVector (DoNotUnboxLazy a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (DoNotUnboxLazy a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a) # basicOverlaps :: MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (DoNotUnboxLazy a)) # basicInitialize :: MVector s (DoNotUnboxLazy a) -> ST s () # basicUnsafeReplicate :: Int -> DoNotUnboxLazy a -> ST s (MVector s (DoNotUnboxLazy a)) # basicUnsafeRead :: MVector s (DoNotUnboxLazy a) -> Int -> ST s (DoNotUnboxLazy a) # basicUnsafeWrite :: MVector s (DoNotUnboxLazy a) -> Int -> DoNotUnboxLazy a -> ST s () # basicClear :: MVector s (DoNotUnboxLazy a) -> ST s () # basicSet :: MVector s (DoNotUnboxLazy a) -> DoNotUnboxLazy a -> ST s () # basicUnsafeCopy :: MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a) -> ST s () # basicUnsafeMove :: MVector s (DoNotUnboxLazy a) -> MVector s (DoNotUnboxLazy a) -> ST s () # basicUnsafeGrow :: MVector s (DoNotUnboxLazy a) -> Int -> ST s (MVector s (DoNotUnboxLazy a)) #
Unbox (DoNotUnboxLazy a)
Instance details Defined in Data.Vector.Unboxed.Base
newtype MVector s (DoNotUnboxLazy a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (DoNotUnboxLazy a) = MV_DoNotUnboxLazy (MVector s a)
newtype Vector (DoNotUnboxLazy a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (DoNotUnboxLazy a) = V_DoNotUnboxLazy (Vector a)

newtype DoNotUnboxNormalForm a #

Constructors

DoNotUnboxNormalForm a

Instances

Instances details

NFData a => Vector Vector (DoNotUnboxNormalForm a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (DoNotUnboxNormalForm a) -> ST s (Vector (DoNotUnboxNormalForm a)) # basicUnsafeThaw :: Vector (DoNotUnboxNormalForm a) -> ST s (Mutable Vector s (DoNotUnboxNormalForm a)) # basicLength :: Vector (DoNotUnboxNormalForm a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxNormalForm a) -> Vector (DoNotUnboxNormalForm a) # basicUnsafeIndexM :: Vector (DoNotUnboxNormalForm a) -> Int -> Box (DoNotUnboxNormalForm a) # basicUnsafeCopy :: Mutable Vector s (DoNotUnboxNormalForm a) -> Vector (DoNotUnboxNormalForm a) -> ST s () # elemseq :: Vector (DoNotUnboxNormalForm a) -> DoNotUnboxNormalForm a -> b -> b #
NFData a => MVector MVector (DoNotUnboxNormalForm a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (DoNotUnboxNormalForm a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a) # basicOverlaps :: MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (DoNotUnboxNormalForm a)) # basicInitialize :: MVector s (DoNotUnboxNormalForm a) -> ST s () # basicUnsafeReplicate :: Int -> DoNotUnboxNormalForm a -> ST s (MVector s (DoNotUnboxNormalForm a)) # basicUnsafeRead :: MVector s (DoNotUnboxNormalForm a) -> Int -> ST s (DoNotUnboxNormalForm a) # basicUnsafeWrite :: MVector s (DoNotUnboxNormalForm a) -> Int -> DoNotUnboxNormalForm a -> ST s () # basicClear :: MVector s (DoNotUnboxNormalForm a) -> ST s () # basicSet :: MVector s (DoNotUnboxNormalForm a) -> DoNotUnboxNormalForm a -> ST s () # basicUnsafeCopy :: MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a) -> ST s () # basicUnsafeMove :: MVector s (DoNotUnboxNormalForm a) -> MVector s (DoNotUnboxNormalForm a) -> ST s () # basicUnsafeGrow :: MVector s (DoNotUnboxNormalForm a) -> Int -> ST s (MVector s (DoNotUnboxNormalForm a)) #
NFData a => Unbox (DoNotUnboxNormalForm a)
Instance details Defined in Data.Vector.Unboxed.Base
newtype MVector s (DoNotUnboxNormalForm a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (DoNotUnboxNormalForm a) = MV_DoNotUnboxNormalForm (MVector s a)
newtype Vector (DoNotUnboxNormalForm a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (DoNotUnboxNormalForm a) = V_DoNotUnboxNormalForm (Vector a)

newtype DoNotUnboxStrict a #

Constructors

DoNotUnboxStrict a

Instances

Instances details

Vector Vector (DoNotUnboxStrict a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (DoNotUnboxStrict a) -> ST s (Vector (DoNotUnboxStrict a)) # basicUnsafeThaw :: Vector (DoNotUnboxStrict a) -> ST s (Mutable Vector s (DoNotUnboxStrict a)) # basicLength :: Vector (DoNotUnboxStrict a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxStrict a) -> Vector (DoNotUnboxStrict a) # basicUnsafeIndexM :: Vector (DoNotUnboxStrict a) -> Int -> Box (DoNotUnboxStrict a) # basicUnsafeCopy :: Mutable Vector s (DoNotUnboxStrict a) -> Vector (DoNotUnboxStrict a) -> ST s () # elemseq :: Vector (DoNotUnboxStrict a) -> DoNotUnboxStrict a -> b -> b #
MVector MVector (DoNotUnboxStrict a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (DoNotUnboxStrict a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a) # basicOverlaps :: MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (DoNotUnboxStrict a)) # basicInitialize :: MVector s (DoNotUnboxStrict a) -> ST s () # basicUnsafeReplicate :: Int -> DoNotUnboxStrict a -> ST s (MVector s (DoNotUnboxStrict a)) # basicUnsafeRead :: MVector s (DoNotUnboxStrict a) -> Int -> ST s (DoNotUnboxStrict a) # basicUnsafeWrite :: MVector s (DoNotUnboxStrict a) -> Int -> DoNotUnboxStrict a -> ST s () # basicClear :: MVector s (DoNotUnboxStrict a) -> ST s () # basicSet :: MVector s (DoNotUnboxStrict a) -> DoNotUnboxStrict a -> ST s () # basicUnsafeCopy :: MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a) -> ST s () # basicUnsafeMove :: MVector s (DoNotUnboxStrict a) -> MVector s (DoNotUnboxStrict a) -> ST s () # basicUnsafeGrow :: MVector s (DoNotUnboxStrict a) -> Int -> ST s (MVector s (DoNotUnboxStrict a)) #
Unbox (DoNotUnboxStrict a)
Instance details Defined in Data.Vector.Unboxed.Base
newtype MVector s (DoNotUnboxStrict a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (DoNotUnboxStrict a) = MV_DoNotUnboxStrict (MVector s a)
newtype Vector (DoNotUnboxStrict a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (DoNotUnboxStrict a) = V_DoNotUnboxStrict (Vector a)

class IsoUnbox a b where #

Minimal complete definition

Nothing

Methods

toURepr :: a -> b #

fromURepr :: b -> a #

newtype UnboxViaPrim a #

Constructors

UnboxViaPrim a

Instances

Instances details

Prim a => Vector Vector (UnboxViaPrim a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (UnboxViaPrim a) -> ST s (Vector (UnboxViaPrim a)) # basicUnsafeThaw :: Vector (UnboxViaPrim a) -> ST s (Mutable Vector s (UnboxViaPrim a)) # basicLength :: Vector (UnboxViaPrim a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (UnboxViaPrim a) -> Vector (UnboxViaPrim a) # basicUnsafeIndexM :: Vector (UnboxViaPrim a) -> Int -> Box (UnboxViaPrim a) # basicUnsafeCopy :: Mutable Vector s (UnboxViaPrim a) -> Vector (UnboxViaPrim a) -> ST s () # elemseq :: Vector (UnboxViaPrim a) -> UnboxViaPrim a -> b -> b #
Prim a => MVector MVector (UnboxViaPrim a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s (UnboxViaPrim a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) # basicOverlaps :: MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (UnboxViaPrim a)) # basicInitialize :: MVector s (UnboxViaPrim a) -> ST s () # basicUnsafeReplicate :: Int -> UnboxViaPrim a -> ST s (MVector s (UnboxViaPrim a)) # basicUnsafeRead :: MVector s (UnboxViaPrim a) -> Int -> ST s (UnboxViaPrim a) # basicUnsafeWrite :: MVector s (UnboxViaPrim a) -> Int -> UnboxViaPrim a -> ST s () # basicClear :: MVector s (UnboxViaPrim a) -> ST s () # basicSet :: MVector s (UnboxViaPrim a) -> UnboxViaPrim a -> ST s () # basicUnsafeCopy :: MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) -> ST s () # basicUnsafeMove :: MVector s (UnboxViaPrim a) -> MVector s (UnboxViaPrim a) -> ST s () # basicUnsafeGrow :: MVector s (UnboxViaPrim a) -> Int -> ST s (MVector s (UnboxViaPrim a)) #
newtype MVector s (UnboxViaPrim a)
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (UnboxViaPrim a) = MV_UnboxViaPrim (MVector s a)
newtype Vector (UnboxViaPrim a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (UnboxViaPrim a) = V_UnboxViaPrim (Vector a)