rio-0.1.22.0: A standard library for Haskell

Safe Haskell | None
Language | Haskell2010

RIO.Vector.Unboxed

Contents

- Unboxed vectors
- Accessors
  - Length information
  - Indexing
  - Extracting subvectors
- Construction
  - Initialisation
  - Monadic initialisation
  - Unfolding
  - Enumeration
  - Concatenation
  - Restricting memory usage
- Modifying vectors
  - Permutations
  - Safe destructive update
- Elementwise operations
  - Indexing
  - Mapping
  - Monadic mapping
  - Zipping
  - Monadic zipping
  - Unzipping
- Working with predicates
  - Filtering
  - Partitioning
  - Searching
- Folding
  - Specialised folds
  - Monadic folds
- Prefix sums (scans)
- Conversions
  - Lists
  - Different vector types
  - Mutable vectors

Description

Unboxed `Vector`. Import as:

    import qualified RIO.Vector.Unboxed as VU

This module does not export any partial or unsafe functions. For those, see RIO.Vector.Unboxed.Partial and RIO.Vector.Unboxed.Unsafe

Synopsis

- data family Vector a
- data family MVector s a
- class (Vector Vector a, MVector MVector a) => Unbox a
- length :: Unbox a => Vector a -> Int
- null :: Unbox a => Vector a -> Bool
- (!?) :: Unbox a => Vector a -> Int -> Maybe a
- slice :: Unbox a => Int -> Int -> 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)
- empty :: Unbox a => Vector a
- singleton :: Unbox a => a -> Vector a
- replicate :: Unbox a => Int -> a -> Vector a
- generate :: Unbox a => Int -> (Int -> a) -> Vector a
- iterateN :: Unbox a => Int -> (a -> a) -> a -> Vector a
- replicateM :: (Monad m, Unbox a) => Int -> m a -> m (Vector a)
- generateM :: (Monad m, Unbox a) => Int -> (Int -> m a) -> m (Vector a)
- iterateNM :: (Monad m, Unbox a) => Int -> (a -> m a) -> a -> m (Vector a)
- create :: Unbox a => (forall s. ST s (MVector s a)) -> Vector a
- createT :: (Traversable f, Unbox a) => (forall s. ST s (f (MVector s a))) -> f (Vector a)
- unfoldr :: Unbox a => (b -> Maybe (a, b)) -> b -> Vector a
- unfoldrN :: Unbox a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
- 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)
- constructN :: Unbox a => Int -> (Vector a -> a) -> Vector a
- constructrN :: Unbox a => Int -> (Vector a -> a) -> Vector a
- enumFromN :: (Unbox a, Num a) => a -> Int -> Vector a
- enumFromStepN :: (Unbox a, Num a) => a -> a -> Int -> Vector a
- enumFromTo :: (Unbox a, Enum a) => a -> a -> Vector a
- enumFromThenTo :: (Unbox a, Enum a) => a -> a -> a -> Vector a
- cons :: Unbox a => a -> Vector a -> Vector a
- snoc :: Unbox a => Vector a -> a -> Vector a
- (++) :: Unbox a => Vector a -> Vector a -> Vector a
- concat :: Unbox a => [Vector a] -> Vector a
- force :: Unbox a => Vector a -> Vector a
- reverse :: Unbox a => Vector a -> Vector a
- modify :: Unbox a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
- indexed :: Unbox a => Vector a -> Vector (Int, a)
- map :: (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
- imap :: (Unbox a, Unbox b) => (Int -> a -> b) -> Vector a -> Vector b
- concatMap :: (Unbox a, Unbox b) => (a -> Vector b) -> Vector a -> Vector b
- mapM :: (Monad m, Unbox a, Unbox b) => (a -> m b) -> Vector a -> m (Vector b)
- imapM :: (Monad m, Unbox a, Unbox b) => (Int -> a -> m b) -> Vector a -> m (Vector b)
- mapM_ :: (Monad m, Unbox a) => (a -> m b) -> Vector a -> m ()
- imapM_ :: (Monad m, Unbox a) => (Int -> a -> m b) -> Vector a -> m ()
- forM :: (Monad m, Unbox a, Unbox b) => Vector a -> (a -> m b) -> m (Vector b)
- forM_ :: (Monad m, Unbox a) => Vector a -> (a -> m b) -> m ()
- zipWith :: (Unbox a, Unbox b, Unbox c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c
- zipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
- zipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
- zipWith5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => (a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
- zipWith6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => (a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
- izipWith :: (Unbox a, Unbox b, Unbox c) => (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
- izipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => (Int -> a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
- izipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (Int -> a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
- izipWith5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => (Int -> a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
- izipWith6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => (Int -> a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
- zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)
- zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a -> Vector b -> Vector c -> Vector (a, b, c)
- zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)
- zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)
- zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector (a, b, c, d, e, f)
- zipWithM :: (Monad m, Unbox a, Unbox b, Unbox c) => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
- izipWithM :: (Monad m, Unbox a, Unbox b, Unbox c) => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
- zipWithM_ :: (Monad m, Unbox a, Unbox b) => (a -> b -> m c) -> Vector a -> Vector b -> m ()
- izipWithM_ :: (Monad m, Unbox a, Unbox b) => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m ()
- unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a, Vector b)
- unzip3 :: (Unbox a, Unbox b, Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
- unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)
- unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector (a, b, c, d, e) -> (Vector a, Vector b, Vector c, Vector d, Vector e)
- unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector (a, b, c, d, e, f) -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
- filter :: Unbox a => (a -> Bool) -> Vector a -> Vector a
- ifilter :: Unbox a => (Int -> a -> Bool) -> Vector a -> Vector a
- uniq :: (Unbox a, Eq a) => Vector a -> Vector a
- mapMaybe :: (Unbox a, Unbox b) => (a -> Maybe b) -> Vector a -> Vector b
- imapMaybe :: (Unbox a, Unbox b) => (Int -> a -> Maybe b) -> Vector a -> Vector b
- filterM :: (Monad m, Unbox a) => (a -> m Bool) -> Vector a -> m (Vector a)
- takeWhile :: Unbox a => (a -> Bool) -> Vector a -> Vector a
- dropWhile :: Unbox a => (a -> Bool) -> Vector a -> Vector a
- partition :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
- unstablePartition :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
- span :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
- break :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
- elem :: (Unbox a, Eq a) => a -> Vector a -> Bool
- notElem :: (Unbox a, Eq a) => a -> Vector a -> Bool
- find :: Unbox a => (a -> Bool) -> Vector a -> Maybe a
- findIndex :: Unbox a => (a -> Bool) -> Vector a -> Maybe Int
- findIndices :: Unbox a => (a -> Bool) -> Vector a -> Vector Int
- elemIndex :: (Unbox a, Eq a) => a -> Vector a -> Maybe Int
- elemIndices :: (Unbox a, Eq a) => a -> Vector a -> Vector Int
- foldl :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
- foldl' :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
- foldr :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
- foldr' :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
- ifoldl :: Unbox b => (a -> Int -> b -> a) -> a -> Vector b -> a
- ifoldl' :: Unbox b => (a -> Int -> b -> a) -> a -> Vector b -> a
- ifoldr :: Unbox a => (Int -> a -> b -> b) -> b -> Vector a -> b
- ifoldr' :: Unbox a => (Int -> a -> b -> b) -> b -> Vector a -> b
- all :: Unbox a => (a -> Bool) -> Vector a -> Bool
- any :: Unbox a => (a -> Bool) -> Vector a -> Bool
- and :: Vector Bool -> Bool
- or :: Vector Bool -> Bool
- sum :: (Unbox a, Num a) => Vector a -> a
- product :: (Unbox a, Num a) => Vector a -> a
- foldM :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
- ifoldM :: (Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
- foldM' :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m a
- ifoldM' :: (Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
- foldM_ :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m ()
- ifoldM_ :: (Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
- foldM'_ :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector b -> m ()
- ifoldM'_ :: (Monad m, Unbox b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
- prescanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- prescanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- postscanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- postscanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- scanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- scanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
- prescanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- prescanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- postscanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- postscanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- scanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- scanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
- toList :: Unbox a => Vector a -> [a]
- fromList :: Unbox a => [a] -> Vector a
- fromListN :: Unbox a => Int -> [a] -> Vector a
- convert :: (Vector v a, Vector w a) => v a -> w a
- freeze :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a)
- thaw :: (Unbox a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a)
- copy :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()

# Unboxed vectors

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 (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 (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 (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 #
NFData (Vector a) |
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: Vector a -> () #
(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) #
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 (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 (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 (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)

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

# Accessors

## Length information

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

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

## Indexing

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

## Extracting subvectors

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

# Construction

## Initialisation

empty :: Unbox a => Vector a #

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

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

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

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

## Monadic initialisation

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

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

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

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

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

## Unfolding

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

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

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

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

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

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

## Enumeration

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

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

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

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

## Concatenation

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

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

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

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

## Restricting memory usage

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

# Modifying vectors

## Permutations

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

## Safe destructive update

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

# Elementwise operations

## Indexing

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

## Mapping

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

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

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

## Monadic mapping

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

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

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

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

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

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

## Zipping

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

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

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

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

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

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

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

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

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

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

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

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

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

zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e) #

zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector (a, b, c, d, e, f) #

## Monadic zipping

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

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

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

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

## Unzipping

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

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

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

unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector (a, b, c, d, e) -> (Vector a, Vector b, Vector c, Vector d, Vector e) #

unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector (a, b, c, d, e, f) -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f) #

# Working with predicates

## Filtering

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

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

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

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

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

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

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

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

## Partitioning

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

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

## Searching

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

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

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

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

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

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

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

# Folding

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

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

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

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

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

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

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

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

## Specialised folds

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

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

and :: Vector Bool -> Bool #

or :: Vector Bool -> Bool #

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

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

## Monadic folds

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

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

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

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

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

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

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

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

# Prefix sums (scans)

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

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

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

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

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

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

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

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

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

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

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

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

# Conversions

## Lists

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

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

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

## Different vector types

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

## Mutable vectors

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

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

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