Safe Haskell | None |
---|---|
Language | Haskell2010 |
RIO.Vector.Unboxed
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
Instances
NFData1 Vector | |
Defined in Data.Vector.Unboxed.Base | |
Vector Vector All | |
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 () # | |
Vector Vector Any | |
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 () # | |
Vector Vector Int16 | |
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 () # | |
Vector Vector Int32 | |
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 () # | |
Vector Vector Int64 | |
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 () # | |
Vector Vector Int8 | |
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 () # | |
Vector Vector Word16 | |
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 () # | |
Vector Vector Word32 | |
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 () # | |
Vector Vector Word64 | |
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 () # | |
Vector Vector Word8 | |
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 () # | |
Vector Vector () | |
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 () # | |
Vector Vector Bool | |
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 () # | |
Vector Vector Char | |
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 () # | |
Vector Vector Double | |
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 () # | |
Vector Vector Float | |
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 () # | |
Vector Vector Int | |
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 () # | |
Vector Vector Word | |
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 () # | |
Unbox a => Vector Vector (Complex a) | |
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 () # | |
Unbox a => Vector Vector (Identity a) | |
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 () # | |
Unbox a => Vector Vector (Down a) | |
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 () # | |
Unbox a => Vector Vector (First a) | |
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 () # | |
Unbox a => Vector Vector (Last a) | |
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 () # | |
Unbox a => Vector Vector (Max a) | |
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 () # | |
Unbox a => Vector Vector (Min a) | |
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 () # | |
Unbox a => Vector Vector (WrappedMonoid a) | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (WrappedMonoid a) -> ST s (Vector (WrappedMonoid a)) # basicUnsafeThaw :: Vector (WrappedMonoid a) -> ST s (Mutable Vector s (WrappedMonoid a)) # basicLength :: Vector (WrappedMonoid a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (WrappedMonoid a) -> Vector (WrappedMonoid a) # basicUnsafeIndexM :: Vector (WrappedMonoid a) -> Int -> Box (WrappedMonoid a) # basicUnsafeCopy :: Mutable Vector s (WrappedMonoid a) -> Vector (WrappedMonoid a) -> ST s () # elemseq :: Vector (WrappedMonoid a) -> WrappedMonoid a -> b -> b # | |
Unbox a => Vector Vector (Dual a) | |
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 () # | |
Unbox a => Vector Vector (Product a) | |
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 () # | |
Unbox a => Vector Vector (Sum a) | |
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 () # | |
Vector Vector (DoNotUnboxLazy a) | |
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) | |
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) | |
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) | |
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) | |
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 () # | |
(IsoUnbox a b, Unbox b) => Vector Vector (As a b) | |
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 () # | |
(Unbox a, Unbox b) => Vector Vector (a, b) | |
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 () # | |
Unbox a => Vector Vector (Const a b) | |
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 () # | |
Unbox (f a) => Vector Vector (Alt f a) | |
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 () # | |
(Unbox a, Unbox b, Unbox c) => Vector Vector (a, b, c) | |
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 () # | |
(Unbox a, Unbox b, Unbox c, Unbox d) => Vector Vector (a, b, c, d) | |
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) | |
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) | |
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) | |
Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s (a, b, c, d, e, f) -> ST s (Vector (a, b, c, d, e, f)) # basicUnsafeThaw :: Vector (a, b, c, d, e, f) -> ST s (Mutable Vector s (a, b, c, d, e, f)) # basicLength :: Vector (a, b, c, d, e, f) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) # basicUnsafeIndexM :: Vector (a, b, c, d, e, f) -> Int -> Box (a, b, c, d, e, f) # basicUnsafeCopy :: Mutable Vector s (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> ST s () # elemseq :: Vector (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> b0 -> b0 # | |
(Data a, Unbox a) => Data (Vector a) | |
Defined in Data.Vector.Unboxed.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) # toConstr :: Vector a -> Constr # dataTypeOf :: Vector a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) # gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # | |
NFData (Vector a) | |
Defined in Data.Vector.Unboxed.Base | |
type Mutable Vector | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector All | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Any | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Int16 | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Int32 | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Int64 | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Int8 | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Word16 | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Word32 | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Word64 | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Word8 | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector () | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Bool | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Char | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Double | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Float | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Int | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector Word | |
Defined in Data.Vector.Unboxed.Base | |
type Item (Vector e) | |
Defined in Data.Vector.Unboxed type Item (Vector e) = e | |
newtype Vector (Complex a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (Identity a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (Down a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (First a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (Last a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (Max a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (Min a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (WrappedMonoid a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (Dual a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (Product a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (Sum a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (DoNotUnboxLazy a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (DoNotUnboxNormalForm a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (DoNotUnboxStrict a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (UnboxViaPrim a) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (Arg a b) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (As a b) | |
Defined in Data.Vector.Unboxed.Base | |
data Vector (a, b) | |
newtype Vector (Const a b) | |
Defined in Data.Vector.Unboxed.Base | |
newtype Vector (Alt f a) | |
Defined in Data.Vector.Unboxed.Base | |
data Vector (a, b, c) | |
data Vector (a, b, c, d) | |
newtype Vector (Compose f g a) | |
Defined in Data.Vector.Unboxed.Base | |
data Vector (a, b, c, d, e) | |
data Vector (a, b, c, d, e, f) | |
Instances
class (Vector Vector a, MVector MVector a) => Unbox a #
Instances
Accessors
Length information
Indexing
Extracting subvectors
Construction
Initialisation
Monadic initialisation
Unfolding
Enumeration
enumFromTo :: (Unbox a, Enum a) => a -> a -> Vector a #
enumFromThenTo :: (Unbox a, Enum a) => a -> a -> a -> Vector a #
Concatenation
Restricting memory usage
Modifying vectors
Permutations
Safe destructive update
Elementwise operations
Indexing
Mapping
Monadic mapping
Zipping
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 #
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) #
izipWithM_ :: (Monad m, Unbox a, Unbox b) => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m () #
Unzipping
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) #