rio-0.1.24.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 -> () Source #
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 -> () Source #
Unbox a => Monoid (Vector a) |
Instance details Defined in Data.Vector.Unboxed Methods mempty :: Vector a Source # mappend :: Vector a -> Vector a -> Vector a Source # mconcat :: [Vector a] -> Vector a Source #
Unbox a => Semigroup (Vector a) |
Instance details Defined in Data.Vector.Unboxed Methods (<>) :: Vector a -> Vector a -> Vector a Source # sconcat :: NonEmpty (Vector a) -> Vector a Source # stimes :: Integral b => b -> Vector a -> Vector a Source #
(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) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) Source #

toConstr :: Vector a -> Constr Source #

dataTypeOf :: Vector a -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) Source #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) Source #

Unbox e => IsList (Vector e) |

Instance details

Defined in Data.Vector.Unboxed

Associated Types

type Item (Vector e) |
Instance details Defined in Data.Vector.Unboxed type Item (Vector e) = e

Methods

fromList :: [Item (Vector e)] -> Vector e Source #

fromListN :: Int -> [Item (Vector e)] -> Vector e Source #

toList :: Vector e -> [Item (Vector e)] Source #

(Read a, Unbox a) => Read (Vector a) |
Instance details Defined in Data.Vector.Unboxed Methods readsPrec :: Int -> ReadS (Vector a) Source # readList :: ReadS [Vector a] Source # readPrec :: ReadPrec (Vector a) Source # readListPrec :: ReadPrec [Vector a] Source #
(Show a, Unbox a) => Show (Vector a) |
Instance details Defined in Data.Vector.Unboxed Methods showsPrec :: Int -> Vector a -> ShowS Source # show :: Vector a -> String Source # showList :: [Vector a] -> ShowS Source #
(Unbox a, Eq a) => Eq (Vector a) |
Instance details Defined in Data.Vector.Unboxed Methods (==) :: Vector a -> Vector a -> Bool Source # (/=) :: Vector a -> Vector a -> Bool Source #
(Unbox a, Ord a) => Ord (Vector a) |
Instance details Defined in Data.Vector.Unboxed Methods compare :: Vector a -> Vector a -> Ordering Source # (<) :: Vector a -> Vector a -> Bool Source # (<=) :: Vector a -> Vector a -> Bool Source # (>) :: Vector a -> Vector a -> Bool Source # (>=) :: Vector a -> Vector a -> Bool Source # max :: Vector a -> Vector a -> Vector a Source # min :: Vector a -> Vector a -> Vector a Source #
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 -> () Source #
NFData (MVector s a) |
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: MVector s a -> () Source #
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 () #