rio-0.1.8.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

Synopsis

- data family Vector a :: Type
- data family MVector s a :: Type
- 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 :: Type Source #

Instances

Vector Vector Bool |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool) Source #

basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool) Source #

basicLength :: Vector Bool -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool Source #

basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m () Source #

elemseq :: Vector Bool -> Bool -> b -> b Source #

Vector Vector Char |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char) Source #

basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char) Source #

basicLength :: Vector Char -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char Source #

basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m () Source #

elemseq :: Vector Char -> Char -> b -> b Source #

Vector Vector Double |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double) Source #

basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double) Source #

basicLength :: Vector Double -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double Source #

basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m () Source #

elemseq :: Vector Double -> Double -> b -> b Source #

Vector Vector Float |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float) Source #

basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float) Source #

basicLength :: Vector Float -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float Source #

basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m () Source #

elemseq :: Vector Float -> Float -> b -> b Source #

Vector Vector Int |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int) Source #

basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int) Source #

basicLength :: Vector Int -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int Source #

basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m () Source #

elemseq :: Vector Int -> Int -> b -> b Source #

Vector Vector Int8 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> m (Vector Int8) Source #

basicUnsafeThaw :: PrimMonad m => Vector Int8 -> m (Mutable Vector (PrimState m) Int8) Source #

basicLength :: Vector Int8 -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8 Source #

basicUnsafeIndexM :: Monad m => Vector Int8 -> Int -> m Int8 Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> Vector Int8 -> m () Source #

elemseq :: Vector Int8 -> Int8 -> b -> b Source #

Vector Vector Int16 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> m (Vector Int16) Source #

basicUnsafeThaw :: PrimMonad m => Vector Int16 -> m (Mutable Vector (PrimState m) Int16) Source #

basicLength :: Vector Int16 -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16 Source #

basicUnsafeIndexM :: Monad m => Vector Int16 -> Int -> m Int16 Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> Vector Int16 -> m () Source #

elemseq :: Vector Int16 -> Int16 -> b -> b Source #

Vector Vector Int32 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> m (Vector Int32) Source #

basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m (Mutable Vector (PrimState m) Int32) Source #

basicLength :: Vector Int32 -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32 Source #

basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32 Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> Vector Int32 -> m () Source #

elemseq :: Vector Int32 -> Int32 -> b -> b Source #

Vector Vector Int64 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> m (Vector Int64) Source #

basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m (Mutable Vector (PrimState m) Int64) Source #

basicLength :: Vector Int64 -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64 Source #

basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64 Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> Vector Int64 -> m () Source #

elemseq :: Vector Int64 -> Int64 -> b -> b Source #

Vector Vector Word |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word) Source #

basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word) Source #

basicLength :: Vector Word -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word Source #

basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m () Source #

elemseq :: Vector Word -> Word -> b -> b Source #

Vector Vector Word8 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8) Source #

basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8) Source #

basicLength :: Vector Word8 -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8 Source #

basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8 Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m () Source #

elemseq :: Vector Word8 -> Word8 -> b -> b Source #

Vector Vector Word16 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> m (Vector Word16) Source #

basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m (Mutable Vector (PrimState m) Word16) Source #

basicLength :: Vector Word16 -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16 Source #

basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16 Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> Vector Word16 -> m () Source #

elemseq :: Vector Word16 -> Word16 -> b -> b Source #

Vector Vector Word32 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> m (Vector Word32) Source #

basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m (Mutable Vector (PrimState m) Word32) Source #

basicLength :: Vector Word32 -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32 Source #

basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32 Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> Vector Word32 -> m () Source #

elemseq :: Vector Word32 -> Word32 -> b -> b Source #

Vector Vector Word64 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> m (Vector Word64) Source #

basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m (Mutable Vector (PrimState m) Word64) Source #

basicLength :: Vector Word64 -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64 Source #

basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64 Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> Vector Word64 -> m () Source #

elemseq :: Vector Word64 -> Word64 -> b -> b Source #

Vector Vector () |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) () -> m (Vector ()) Source #

basicUnsafeThaw :: PrimMonad m => Vector () -> m (Mutable Vector (PrimState m) ()) Source #

basicLength :: Vector () -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector () -> Vector () Source #

basicUnsafeIndexM :: Monad m => Vector () -> Int -> m () Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) () -> Vector () -> m () Source #

elemseq :: Vector () -> () -> b -> b Source #

Unbox a => Vector Vector (Complex a) |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> m (Vector (Complex a)) Source #

basicUnsafeThaw :: PrimMonad m => Vector (Complex a) -> m (Mutable Vector (PrimState m) (Complex a)) Source #

basicLength :: Vector (Complex a) -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a) Source #

basicUnsafeIndexM :: Monad m => Vector (Complex a) -> Int -> m (Complex a) Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> Vector (Complex a) -> m () Source #

elemseq :: Vector (Complex a) -> Complex a -> b -> b Source #

(Unbox a, Unbox b) => Vector Vector (a, b) |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> m (Vector (a, b)) Source #

basicUnsafeThaw :: PrimMonad m => Vector (a, b) -> m (Mutable Vector (PrimState m) (a, b)) Source #

basicLength :: Vector (a, b) -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector (a, b) -> Vector (a, b) Source #

basicUnsafeIndexM :: Monad m => Vector (a, b) -> Int -> m (a, b) Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> Vector (a, b) -> m () Source #

elemseq :: Vector (a, b) -> (a, b) -> b0 -> b0 Source #

(Unbox a, Unbox b, Unbox c) => Vector Vector (a, b, c) |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> m (Vector (a, b, c)) Source #

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c) -> m (Mutable Vector (PrimState m) (a, b, c)) Source #

basicLength :: Vector (a, b, c) -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c) -> Vector (a, b, c) Source #

basicUnsafeIndexM :: Monad m => Vector (a, b, c) -> Int -> m (a, b, c) Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> Vector (a, b, c) -> m () Source #

elemseq :: Vector (a, b, c) -> (a, b, c) -> b0 -> b0 Source #

(Unbox a, Unbox b, Unbox c, Unbox d) => Vector Vector (a, b, c, d) |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> m (Vector (a, b, c, d)) Source #

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d) -> m (Mutable Vector (PrimState m) (a, b, c, d)) Source #

basicLength :: Vector (a, b, c, d) -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d) -> Vector (a, b, c, d) Source #

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d) -> Int -> m (a, b, c, d) Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> Vector (a, b, c, d) -> m () Source #

elemseq :: Vector (a, b, c, d) -> (a, b, c, d) -> b0 -> b0 Source #

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector Vector (a, b, c, d, e) |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> m (Vector (a, b, c, d, e)) Source #

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e) -> m (Mutable Vector (PrimState m) (a, b, c, d, e)) Source #

basicLength :: Vector (a, b, c, d, e) -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e) -> Vector (a, b, c, d, e) Source #

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e) -> Int -> m (a, b, c, d, e) Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> Vector (a, b, c, d, e) -> m () Source #

elemseq :: Vector (a, b, c, d, e) -> (a, b, c, d, e) -> b0 -> b0 Source #

(Unbox 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 :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> m (Vector (a, b, c, d, e, f)) Source #

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e, f) -> m (Mutable Vector (PrimState m) (a, b, c, d, e, f)) Source #

basicLength :: Vector (a, b, c, d, e, f) -> Int Source #

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) Source #

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f) Source #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> m () Source #

elemseq :: Vector (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> b0 -> b0 Source #

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

NFData (Vector a) |
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: Vector a -> () Source #
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 Int8 |
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int8 = V_Int8 (Vector Int8)
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 Word |
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word = V_Word (Vector Word)
newtype Vector Word8 |
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word8 = V_Word8 (Vector Word8)
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 () |
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector () = V_Unit Int
type Mutable Vector |
Instance details Defined in Data.Vector.Unboxed.Base type Mutable Vector = MVector
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))
data Vector (a, b) |
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b) = V_2 !Int !(Vector a) !(Vector b)
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)
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 :: Type Source #

Instances

MVector MVector Bool |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Bool -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool Source #

basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Bool) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool) Source #

MVector MVector Char |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Char -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char Source #

basicOverlaps :: MVector s Char -> MVector s Char -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Char -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char) Source #

MVector MVector Double |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Double -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double Source #

basicOverlaps :: MVector s Double -> MVector s Double -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Double) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Double -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) Double) Source #

MVector MVector Float |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Float -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float Source #

basicOverlaps :: MVector s Float -> MVector s Float -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Float) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Float -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) Float) Source #

MVector MVector Int |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int Source #

basicOverlaps :: MVector s Int -> MVector s Int -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Int -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int) Source #

MVector MVector Int8 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int8 -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Int8 -> MVector s Int8 Source #

basicOverlaps :: MVector s Int8 -> MVector s Int8 -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int8) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Int8 -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Int8 -> m (MVector (PrimState m) Int8) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m Int8 Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> Int8 -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Int8 -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Int8 -> Int8 -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m (MVector (PrimState m) Int8) Source #

MVector MVector Int16 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int16 -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Int16 -> MVector s Int16 Source #

basicOverlaps :: MVector s Int16 -> MVector s Int16 -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int16) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Int16 -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Int16 -> m (MVector (PrimState m) Int16) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m Int16 Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> Int16 -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Int16 -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Int16 -> Int16 -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m (MVector (PrimState m) Int16) Source #

MVector MVector Int32 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int32 -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Int32 -> MVector s Int32 Source #

basicOverlaps :: MVector s Int32 -> MVector s Int32 -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int32) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Int32 -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Int32 -> m (MVector (PrimState m) Int32) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m Int32 Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> Int32 -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Int32 -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Int32 -> Int32 -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m (MVector (PrimState m) Int32) Source #

MVector MVector Int64 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Int64 -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Int64 -> MVector s Int64 Source #

basicOverlaps :: MVector s Int64 -> MVector s Int64 -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Int64) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Int64 -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m (MVector (PrimState m) Int64) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m Int64 Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> Int64 -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Int64 -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Int64 -> Int64 -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m (MVector (PrimState m) Int64) Source #

MVector MVector Word |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word Source #

basicOverlaps :: MVector s Word -> MVector s Word -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Word -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word) Source #

MVector MVector Word8 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word8 -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Word8 -> MVector s Word8 Source #

basicOverlaps :: MVector s Word8 -> MVector s Word8 -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word8) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Word8 -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m (MVector (PrimState m) Word8) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m Word8 Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> Word8 -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Word8 -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Word8 -> Word8 -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m (MVector (PrimState m) Word8) Source #

MVector MVector Word16 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word16 -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Word16 -> MVector s Word16 Source #

basicOverlaps :: MVector s Word16 -> MVector s Word16 -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word16) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Word16 -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Word16 -> m (MVector (PrimState m) Word16) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m Word16 Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> Word16 -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Word16 -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Word16 -> Word16 -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m (MVector (PrimState m) Word16) Source #

MVector MVector Word32 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word32 -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Word32 -> MVector s Word32 Source #

basicOverlaps :: MVector s Word32 -> MVector s Word32 -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word32) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Word32 -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Word32 -> m (MVector (PrimState m) Word32) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m Word32 Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> Word32 -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Word32 -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Word32 -> Word32 -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m (MVector (PrimState m) Word32) Source #

MVector MVector Word64 |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s Word64 -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s Word64 -> MVector s Word64 Source #

basicOverlaps :: MVector s Word64 -> MVector s Word64 -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Word64) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) Word64 -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Word64 -> m (MVector (PrimState m) Word64) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m Word64 Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> Word64 -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) Word64 -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) Word64 -> Word64 -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m (MVector (PrimState m) Word64) Source #

MVector MVector () |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s () -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s () -> MVector s () Source #

basicOverlaps :: MVector s () -> MVector s () -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) ()) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) () -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> () -> m (MVector (PrimState m) ()) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) () -> Int -> m () Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) () -> Int -> () -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) () -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) () -> () -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) () -> Int -> m (MVector (PrimState m) ()) Source #

Unbox a => MVector MVector (Complex a) |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Complex a) -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s (Complex a) -> MVector s (Complex a) Source #

basicOverlaps :: MVector s (Complex a) -> MVector s (Complex a) -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Complex a)) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) (Complex a) -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> Complex a -> m (MVector (PrimState m) (Complex a)) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (Complex a) Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> Complex a -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) (Complex a) -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) (Complex a) -> Complex a -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (MVector (PrimState m) (Complex a)) Source #

(Unbox a, Unbox b) => MVector MVector (a, b) |

Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (a, b) -> Int Source #

basicUnsafeSlice :: Int -> Int -> MVector s (a, b) -> MVector s (a, b) Source #

basicOverlaps :: MVector s (a, b) -> MVector s (a, b) -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b)) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b) -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b) -> m (MVector (PrimState m) (a, b)) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> m (a, b) Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> (a, b) -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b) -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b) -> (a, b) -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b) -> MVector (PrimState m) (a, b) -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b) -> MVector (PrimState m) (a, b) -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> m (MVector (PrimState m) (a, b)) Source #

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

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c) -> MVector s (a, b, c) Source #

basicOverlaps :: MVector s (a, b, c) -> MVector s (a, b, c) -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c)) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c) -> m (MVector (PrimState m) (a, b, c)) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (a, b, c) Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> (a, b, c) -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c) -> (a, b, c) -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (MVector (PrimState m) (a, b, c)) Source #

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

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d) -> MVector s (a, b, c, d) Source #

basicOverlaps :: MVector s (a, b, c, d) -> MVector s (a, b, c, d) -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d)) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d) -> m (MVector (PrimState m) (a, b, c, d)) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (a, b, c, d) Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> (a, b, c, d) -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> (a, b, c, d) -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (MVector (PrimState m) (a, b, c, d)) Source #

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

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) Source #

basicOverlaps :: MVector s (a, b, c, d, e) -> MVector s (a, b, c, d, e) -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e)) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e) -> m (MVector (PrimState m) (a, b, c, d, e)) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (a, b, c, d, e) Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> (a, b, c, d, e) -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> (a, b, c, d, e) -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (MVector (PrimState m) (a, b, c, d, e)) Source #

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

basicUnsafeSlice :: Int -> Int -> MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) Source #

basicOverlaps :: MVector s (a, b, c, d, e, f) -> MVector s (a, b, c, d, e, f) -> Bool Source #

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e, f)) Source #

basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m () Source #

basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e, f) -> m (MVector (PrimState m) (a, b, c, d, e, f)) Source #

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f) Source #

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> (a, b, c, d, e, f) -> m () Source #

basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m () Source #

basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> m () Source #

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m () Source #

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m () Source #

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (MVector (PrimState m) (a, b, c, d, e, f)) Source #

NFData (MVector s a) |
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: MVector s a -> () Source #
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 Word64 |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word64 = MV_Word64 (MVector s Word64)
newtype MVector s Word32 |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word32 = MV_Word32 (MVector s Word32)
newtype MVector s Word16 |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word16 = MV_Word16 (MVector s Word16)
newtype MVector s Word8 |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word8 = MV_Word8 (MVector s Word8)
newtype MVector s Word |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word = MV_Word (MVector s Word)
newtype MVector s Int64 |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int64 = MV_Int64 (MVector s Int64)
newtype MVector s Int32 |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int32 = MV_Int32 (MVector s Int32)
newtype MVector s Int16 |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int16 = MV_Int16 (MVector s Int16)
newtype MVector s Int8 |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int8 = MV_Int8 (MVector s Int8)
newtype MVector s Int |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int = MV_Int (MVector s Int)
newtype MVector s () |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s () = MV_Unit Int
newtype MVector s (Complex a) |
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s (Complex a) = MV_Complex (MVector s (a, a))
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)
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)
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 Source #

Instances

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 Int8 |
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 Word |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word8 |
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 () |
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Complex a) |
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 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 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 Source #

O(1) Yield the length of the vector

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

O(1) Test whether a vector is empty

## Indexing

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

O(1) Safe indexing

## Extracting subvectors

slice Source #

Arguments

:: Unbox a |
=> Int | `i` starting index
-> Int | `n` length
-> Vector a |
-> Vector a |

O(1) Yield a slice of the vector without copying it. The vector must contain at least `i+n` elements.

take :: Unbox a => Int -> Vector a -> Vector a Source #

O(1) Yield at the first `n` elements without copying. The vector may contain less than `n` elements in which case it is returned unchanged.

drop :: Unbox a => Int -> Vector a -> Vector a Source #

O(1) Yield all but the first `n` elements without copying. The vector may contain less than `n` elements in which case an empty vector is returned.

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

O(1) Yield the first `n` elements paired with the remainder without copying.

Note that ``splitAt` n v` is equivalent to `(`take` n v, `drop` n v)` but slightly more efficient.

# Construction

## Initialisation

empty :: Unbox a => Vector a Source #

O(1) Empty vector

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

O(1) Vector with exactly one element

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

O(n) Vector of the given length with the same value in each position

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

O(n) Construct a vector of the given length by applying the function to each index

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

O(n) Apply function n times to value. Zeroth element is original value.

## Monadic initialisation

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

O(n) Execute the monadic action the given number of times and store the results in a vector.

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

O(n) Construct a vector of the given length by applying the monadic action to each index

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

O(n) Apply monadic function n times to value. Zeroth element is original value.

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

Execute the monadic action and freeze the resulting vector.

    create (do { v <- new 2; write v 0 'a'; write v 1 'b'; return v }) = <a,b>

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

Execute the monadic action and freeze the resulting vectors.

## Unfolding

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

O(n) Construct a vector by repeatedly applying the generator function to a seed. The generator function yields `Just` the next element and the new seed or `Nothing` if there are no more elements.

    unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10
     = <10,9,8,7,6,5,4,3,2,1>

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

O(n) Construct a vector with at most `n` elements by repeatedly applying the generator function to a seed. The generator function yields `Just` the next element and the new seed or `Nothing` if there are no more elements.

    unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8>

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

O(n) Construct a vector by repeatedly applying the monadic generator function to a seed. The generator function yields `Just` the next element and the new seed or `Nothing` if there are no more elements.

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

O(n) Construct a vector by repeatedly applying the monadic generator function to a seed. The generator function yields `Just` the next element and the new seed or `Nothing` if there are no more elements.

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

O(n) Construct a vector with `n` elements by repeatedly applying the generator function to the already constructed part of the vector.

    constructN 3 f = let a = f <> ; b = f <a> ; c = f <a,b> in f <a,b,c>

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

O(n) Construct a vector with `n` elements from right to left by repeatedly applying the generator function to the already constructed part of the vector.

    constructrN 3 f = let a = f <> ; b = f<a> ; c = f <b,a> in f <c,b,a>

## Enumeration

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

O(n) Yield a vector of the given length containing the values `x`, `x+1` etc. This operation is usually more efficient than `enumFromTo`.

    enumFromN 5 3 = <5,6,7>

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

O(n) Yield a vector of the given length containing the values `x`, `x+y`, `x+y+y` etc. This operations is usually more efficient than `enumFromThenTo`.

    enumFromStepN 1 0.1 5 = <1,1.1,1.2,1.3,1.4>

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

O(n) Enumerate values from `x` to `y`.

WARNING: This operation can be very inefficient. If at all possible, use `enumFromN` instead.

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

O(n) Enumerate values from `x` to `y` with a specific step `z`.

WARNING: This operation can be very inefficient. If at all possible, use `enumFromStepN` instead.

## Concatenation

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

O(n) Prepend an element

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

O(n) Append an element

(++) :: Unbox a => Vector a -> Vector a -> Vector a infixr 5 Source #

O(m+n) Concatenate two vectors

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

O(n) Concatenate all vectors in the list

## Restricting memory usage

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

O(n) Yield the argument but force it not to retain any extra memory, possibly by copying it.

This is especially useful when dealing with slices. For example:

    force (slice 0 2 <huge vector>)

Here, the slice retains a reference to the huge vector. Forcing it creates a copy of just the elements that belong to the slice and allows the huge vector to be garbage collected.

# Modifying vectors

## Permutations

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

O(n) Reverse a vector

## Safe destructive update

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

Apply a destructive operation to a vector. The operation will be performed in place if it is safe to do so and will modify a copy of the vector otherwise.

    modify (\v -> write v 0 'x') (replicate 3 'a') = <'x','a','a'>

# Elementwise operations

## Indexing

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

O(n) Pair each element in a vector with its index

## Mapping

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

O(n) Map a function over a vector

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

O(n) Apply a function to every element of a vector and its index

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

Map a function over a vector and concatenate the results.

## Monadic mapping

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

O(n) Apply the monadic action to all elements of the vector, yielding a vector of results

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

O(n) Apply the monadic action to every element of a vector and its index, yielding a vector of results

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

O(n) Apply the monadic action to all elements of a vector and ignore the results

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

O(n) Apply the monadic action to every element of a vector and its index, ignoring the results

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

O(n) Apply the monadic action to all elements of the vector, yielding a vector of results. Equivalent to `flip `mapM``.

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

O(n) Apply the monadic action to all elements of a vector and ignore the results. Equivalent to `flip `mapM_``.

## Zipping

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

O(min(m,n)) Zip two vectors with the given function.

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

Zip three vectors with the given function.

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

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

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

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

O(min(m,n)) Zip two vectors with a function that also takes the elements' indices.

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

Zip three vectors and their indices with the given function.

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

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

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

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

O(1) Zip 2 vectors

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

O(1) Zip 3 vectors

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

O(1) Zip 4 vectors

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

O(1) Zip 5 vectors

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

O(1) Zip 6 vectors

## Monadic zipping

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

O(min(m,n)) Zip the two vectors with the monadic action and yield a vector of results

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

O(min(m,n)) Zip the two vectors with a monadic action that also takes the element index and yield a vector of results

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

O(min(m,n)) Zip the two vectors with the monadic action and ignore the results

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

O(min(m,n)) Zip the two vectors with a monadic action that also takes the element index and ignore the results

## Unzipping

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

O(1) Unzip 2 vectors

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

O(1) Unzip 3 vectors

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

O(1) Unzip 4 vectors

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

O(1) Unzip 5 vectors

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

O(1) Unzip 6 vectors

# Working with predicates

## Filtering

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

O(n) Drop elements that do not satisfy the predicate

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

O(n) Drop elements that do not satisfy the predicate which is applied to values and their indices

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

O(n) Drop repeated adjacent elements.

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

O(n) Drop elements when predicate returns Nothing

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

O(n) Drop elements when predicate, applied to index and value, returns Nothing

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

O(n) Drop elements that do not satisfy the monadic predicate

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

O(n) Yield the longest prefix of elements satisfying the predicate without copying.

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

O(n) Drop the longest prefix of elements that satisfy the predicate without copying.

## Partitioning

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

O(n) Split the vector in two parts, the first one containing those elements that satisfy the predicate and the second one those that don't. The relative order of the elements is preserved at the cost of a sometimes reduced performance compared to `unstablePartition`.

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

O(n) Split the vector in two parts, the first one containing those elements that satisfy the predicate and the second one those that don't. The order of the elements is not preserved but the operation is often faster than `partition`.

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

O(n) Split the vector into the longest prefix of elements that satisfy the predicate and the rest without copying.

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

O(n) Split the vector into the longest prefix of elements that do not satisfy the predicate and the rest without copying.

## Searching

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

O(n) Check if the vector contains an element

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

O(n) Check if the vector does not contain an element (inverse of `elem`)

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

O(n) Yield `Just` the first element matching the predicate or `Nothing` if no such element exists.

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

O(n) Yield `Just` the index of the first element matching the predicate or `Nothing` if no such element exists.

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

O(n) Yield the indices of elements satisfying the predicate in ascending order.

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

O(n) Yield `Just` the index of the first occurence of the given element or `Nothing` if the vector does not contain the element. This is a specialised version of `findIndex`.

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

O(n) Yield the indices of all occurences of the given element in ascending order. This is a specialised version of `findIndices`.

# Folding

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

O(n) Left fold

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

O(n) Left fold with strict accumulator

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

O(n) Right fold

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

O(n) Right fold with a strict accumulator

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

O(n) Left fold (function applied to each element and its index)

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

O(n) Left fold with strict accumulator (function applied to each element and its index)

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

O(n) Right fold (function applied to each element and its index)

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

O(n) Right fold with strict accumulator (function applied to each element and its index)

## Specialised folds

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

O(n) Check if all elements satisfy the predicate.

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

O(n) Check if any element satisfies the predicate.

and :: Vector Bool -> Bool Source #

O(n) Check if all elements are `True`

or :: Vector Bool -> Bool Source #

O(n) Check if any element is `True`

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

O(n) Compute the sum of the elements

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

O(n) Compute the produce of the elements

## Monadic folds

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

O(n) Monadic fold

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

O(n) Monadic fold (action applied to each element and its index)

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

O(n) Monadic fold with strict accumulator

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

O(n) Monadic fold with strict accumulator (action applied to each element and its index)

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

O(n) Monadic fold that discards the result

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

O(n) Monadic fold that discards the result (action applied to each element and its index)

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

O(n) Monadic fold with strict accumulator that discards the result

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

O(n) Monadic fold with strict accumulator that discards the result (action applied to each element and its index)

# Prefix sums (scans)

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

O(n) Prescan

    prescanl f z = init . scanl f z

Example: `prescanl (+) 0 <1,2,3,4> = <0,1,3,6>`

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

O(n) Prescan with strict accumulator

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

O(n) Scan

    postscanl f z = tail . scanl f z

Example: `postscanl (+) 0 <1,2,3,4> = <1,3,6,10>`

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

O(n) Scan with strict accumulator

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

O(n) Haskell-style scan

    scanl f z <x1,...,xn> = <y1,...,y(n+1)>
      where y1 = z
            yi = f y(i-1) x(i-1)

Example: `scanl (+) 0 <1,2,3,4> = <0,1,3,6,10>`

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

O(n) Haskell-style scan with strict accumulator

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

O(n) Right-to-left prescan

    prescanr f z = reverse . prescanl (flip f) z . reverse

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

O(n) Right-to-left prescan with strict accumulator

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

O(n) Right-to-left scan

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

O(n) Right-to-left scan with strict accumulator

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

O(n) Right-to-left Haskell-style scan

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

O(n) Right-to-left Haskell-style scan with strict accumulator

# Conversions

## Lists

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

O(n) Convert a vector to a list

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

O(n) Convert a list to a vector

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

O(n) Convert the first `n` elements of a list to a vector

    fromListN n xs = fromList (take n xs)

## Different vector types

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

O(n) Convert different vector types

## Mutable vectors

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

O(n) Yield an immutable copy of the mutable vector.

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

O(n) Yield a mutable copy of the immutable vector.

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

O(n) Copy an immutable vector into a mutable one. The two vectors must have the same length.