Safe Haskell	None
Language	Haskell2010

Data.Text32

Synopsis

type Text32 = Vector Char
data family Vector a :: *
class (Vector Vector a, MVector MVector a) => Unbox a
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)
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)
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)
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)
unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)
zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)
unzip3 :: (Unbox a, Unbox b, Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a -> Vector b -> Vector c -> Vector (a, b, c)
unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a, Vector b)
zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)
copy :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
unsafeCopy :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
freeze :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a)
thaw :: (Unbox a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a)
unsafeThaw :: (Unbox a, PrimMonad m) => Vector a -> m (MVector (PrimState m) a)
unsafeFreeze :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> m (Vector a)
fromListN :: Unbox a => Int -> [a] -> Vector a
fromList :: Unbox a => [a] -> Vector a
toList :: Unbox a => Vector a -> [a]
scanr1' :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
scanr1 :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
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
postscanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
postscanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
prescanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
prescanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanl1' :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
scanl1 :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
scanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
scanl :: (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
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
fold1M'_ :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> 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 ()
fold1M_ :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> 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 ()
fold1M' :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> 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
fold1M :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector a -> 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
minIndexBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> Int
minIndex :: (Unbox a, Ord a) => Vector a -> Int
maxIndexBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> Int
maxIndex :: (Unbox a, Ord a) => Vector a -> Int
minimumBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> a
minimum :: (Unbox a, Ord a) => Vector a -> a
maximumBy :: Unbox a => (a -> a -> Ordering) -> Vector a -> a
maximum :: (Unbox a, Ord a) => Vector a -> a
product :: (Unbox a, Num a) => Vector a -> a
sum :: (Unbox a, Num a) => Vector a -> a
or :: Vector Bool -> Bool
and :: Vector Bool -> Bool
any :: Unbox a => (a -> Bool) -> Vector a -> Bool
all :: Unbox a => (a -> Bool) -> Vector a -> Bool
ifoldr' :: Unbox a => (Int -> a -> b -> b) -> b -> Vector a -> b
ifoldr :: Unbox a => (Int -> 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
foldr1' :: Unbox a => (a -> a -> a) -> Vector a -> a
foldr' :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
foldr1 :: Unbox a => (a -> a -> a) -> Vector a -> a
foldr :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
foldl1' :: Unbox a => (a -> a -> a) -> Vector a -> a
foldl' :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
foldl1 :: Unbox a => (a -> a -> a) -> Vector a -> a
foldl :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
elemIndices :: (Unbox a, Eq a) => a -> Vector a -> Vector Int
elemIndex :: (Unbox a, Eq a) => a -> Vector a -> Maybe Int
findIndices :: Unbox a => (a -> Bool) -> Vector a -> Vector Int
findIndex :: Unbox a => (a -> Bool) -> Vector a -> Maybe Int
find :: Unbox a => (a -> Bool) -> Vector a -> Maybe a
notElem :: (Unbox a, Eq a) => a -> Vector a -> Bool
elem :: (Unbox a, Eq a) => a -> Vector a -> Bool
break :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
span :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
unstablePartition :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
partition :: Unbox a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
dropWhile :: Unbox a => (a -> Bool) -> Vector a -> Vector a
takeWhile :: Unbox a => (a -> Bool) -> Vector a -> Vector a
filterM :: (Monad m, Unbox a) => (a -> m Bool) -> Vector a -> m (Vector a)
imapMaybe :: (Unbox a, Unbox b) => (Int -> a -> Maybe b) -> Vector a -> Vector b
mapMaybe :: (Unbox a, Unbox b) => (a -> Maybe b) -> Vector a -> Vector b
ifilter :: Unbox a => (Int -> a -> Bool) -> Vector a -> Vector a
uniq :: (Unbox a, Eq a) => Vector a -> Vector a
filter :: Unbox a => (a -> Bool) -> Vector a -> Vector a
izipWithM_ :: (Monad m, Unbox a, Unbox b) => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m ()
zipWithM_ :: (Monad m, Unbox a, Unbox b) => (a -> b -> m c) -> Vector a -> Vector b -> m ()
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, Unbox c) => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
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
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
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
izipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => (Int -> a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
izipWith :: (Unbox a, Unbox b, Unbox c) => (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
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
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
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
zipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
zipWith :: (Unbox a, Unbox b, Unbox c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c
forM_ :: (Monad m, Unbox a) => Vector a -> (a -> m b) -> m ()
forM :: (Monad m, Unbox a, Unbox b) => Vector a -> (a -> m b) -> m (Vector b)
imapM_ :: (Monad m, Unbox a) => (Int -> a -> m b) -> Vector a -> m ()
mapM_ :: (Monad m, Unbox a) => (a -> m b) -> Vector a -> m ()
imapM :: (Monad m, Unbox a, Unbox b) => (Int -> a -> m b) -> Vector a -> m (Vector b)
mapM :: (Monad m, Unbox a, Unbox b) => (a -> m b) -> Vector a -> m (Vector b)
concatMap :: (Unbox a, Unbox b) => (a -> Vector b) -> Vector a -> Vector b
imap :: (Unbox a, Unbox b) => (Int -> a -> b) -> Vector a -> Vector b
map :: (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
indexed :: Unbox a => Vector a -> Vector (Int, a)
modify :: Unbox a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
unsafeBackpermute :: Unbox a => Vector a -> Vector Int -> Vector a
backpermute :: Unbox a => Vector a -> Vector Int -> Vector a
reverse :: Unbox a => Vector a -> Vector a
unsafeAccumulate_ :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
unsafeAccumulate :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
unsafeAccum :: Unbox a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
accumulate_ :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
accumulate :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
accum :: Unbox a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
unsafeUpdate_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a
unsafeUpdate :: Unbox a => Vector a -> Vector (Int, a) -> Vector a
unsafeUpd :: Unbox a => Vector a -> [(Int, a)] -> Vector a
update_ :: Unbox a => Vector a -> Vector Int -> Vector a -> Vector a
update :: Unbox a => Vector a -> Vector (Int, a) -> Vector a
(//) :: Unbox a => Vector a -> [(Int, a)] -> Vector a
force :: Unbox a => Vector a -> Vector a
createT :: (Traversable f, Unbox a) => (forall s. ST s (f (MVector s a))) -> f (Vector a)
create :: Unbox a => (forall s. ST s (MVector s a)) -> Vector a
iterateNM :: (Monad m, Unbox a) => Int -> (a -> m a) -> a -> m (Vector a)
generateM :: (Monad m, Unbox a) => Int -> (Int -> m a) -> m (Vector a)
replicateM :: (Monad m, Unbox a) => Int -> m a -> m (Vector a)
concat :: Unbox a => [Vector a] -> Vector a
(++) :: Unbox a => Vector a -> Vector a -> Vector a
snoc :: Unbox a => Vector a -> a -> Vector a
cons :: Unbox a => a -> Vector a -> Vector a
enumFromThenTo :: (Unbox a, Enum a) => a -> a -> a -> Vector a
enumFromTo :: (Unbox a, Enum a) => a -> a -> Vector a
enumFromStepN :: (Unbox a, Num a) => a -> a -> Int -> Vector a
enumFromN :: (Unbox a, Num a) => a -> Int -> Vector a
constructrN :: Unbox a => Int -> (Vector a -> a) -> Vector a
constructN :: Unbox a => Int -> (Vector a -> a) -> Vector a
unfoldrNM :: (Monad m, Unbox a) => Int -> (b -> m (Maybe (a, b))) -> b -> m (Vector a)
unfoldrM :: (Monad m, Unbox a) => (b -> m (Maybe (a, b))) -> b -> m (Vector a)
unfoldrN :: Unbox a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
unfoldr :: Unbox a => (b -> Maybe (a, b)) -> b -> Vector a
iterateN :: Unbox a => Int -> (a -> a) -> a -> Vector a
generate :: Unbox a => Int -> (Int -> a) -> Vector a
replicate :: Unbox a => Int -> a -> Vector a
singleton :: Unbox a => a -> Vector a
empty :: Unbox a => Vector a
unsafeDrop :: Unbox a => Int -> Vector a -> Vector a
unsafeTake :: Unbox a => Int -> Vector a -> Vector a
unsafeTail :: Unbox a => Vector a -> Vector a
unsafeInit :: Unbox a => Vector a -> Vector a
unsafeSlice :: Unbox a => Int -> Int -> Vector a -> Vector a
splitAt :: Unbox a => Int -> Vector a -> (Vector a, Vector a)
drop :: Unbox a => Int -> Vector a -> Vector a
take :: Unbox a => Int -> Vector a -> Vector a
tail :: Unbox a => Vector a -> Vector a
init :: Unbox a => Vector a -> Vector a
slice :: Unbox a => Int -> Int -> Vector a -> Vector a
unsafeLastM :: (Unbox a, Monad m) => Vector a -> m a
unsafeHeadM :: (Unbox a, Monad m) => Vector a -> m a
unsafeIndexM :: (Unbox a, Monad m) => Vector a -> Int -> m a
lastM :: (Unbox a, Monad m) => Vector a -> m a
headM :: (Unbox a, Monad m) => Vector a -> m a
indexM :: (Unbox a, Monad m) => Vector a -> Int -> m a
unsafeLast :: Unbox a => Vector a -> a
unsafeHead :: Unbox a => Vector a -> a
unsafeIndex :: Unbox a => Vector a -> Int -> a
last :: Unbox a => Vector a -> a
head :: Unbox a => Vector a -> a
(!?) :: Unbox a => Vector a -> Int -> Maybe a
(!) :: Unbox a => Vector a -> Int -> a
null :: Unbox a => Vector a -> Bool
length :: Unbox a => Vector a -> Int
data family MVector s a :: *
convert :: (Vector v a, Vector w a) => v a -> w a
index :: Vector v a => v a -> Int -> Maybe a
replace :: (Vector v a, Eq a) => a -> v a -> v a -> v a
commonPrefixes :: (Vector v a, Eq a) => v a -> v a -> Maybe (v a, v a, v a)

Documentation

type Text32 = Vector Char Source #

data family Vector a :: * #

Instances

Vector Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool) # basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool) # basicLength :: Vector Bool -> Int # basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool # basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m () # elemseq :: Vector Bool -> Bool -> b -> b #
Vector Vector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char) # basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char) # basicLength :: Vector Char -> Int # basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char # basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m () # elemseq :: Vector Char -> Char -> b -> b #
Vector Vector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double) # basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double) # basicLength :: Vector Double -> Int # basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double # basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m () # elemseq :: Vector Double -> Double -> b -> b #
Vector Vector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float) # basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float) # basicLength :: Vector Float -> Int # basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float # basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m () # elemseq :: Vector Float -> Float -> b -> b #
Vector Vector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int) # basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int) # basicLength :: Vector Int -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int # basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m () # elemseq :: Vector Int -> Int -> b -> b #
Vector Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> m (Vector Int8) # basicUnsafeThaw :: PrimMonad m => Vector Int8 -> m (Mutable Vector (PrimState m) Int8) # basicLength :: Vector Int8 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8 # basicUnsafeIndexM :: Monad m => Vector Int8 -> Int -> m Int8 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> Vector Int8 -> m () # elemseq :: Vector Int8 -> Int8 -> b -> b #
Vector Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> m (Vector Int16) # basicUnsafeThaw :: PrimMonad m => Vector Int16 -> m (Mutable Vector (PrimState m) Int16) # basicLength :: Vector Int16 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16 # basicUnsafeIndexM :: Monad m => Vector Int16 -> Int -> m Int16 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> Vector Int16 -> m () # elemseq :: Vector Int16 -> Int16 -> b -> b #
Vector Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> m (Vector Int32) # basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m (Mutable Vector (PrimState m) Int32) # basicLength :: Vector Int32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32 # basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> Vector Int32 -> m () # elemseq :: Vector Int32 -> Int32 -> b -> b #
Vector Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> m (Vector Int64) # basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m (Mutable Vector (PrimState m) Int64) # basicLength :: Vector Int64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64 # basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> Vector Int64 -> m () # elemseq :: Vector Int64 -> Int64 -> b -> b #
Vector Vector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word) # basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word) # basicLength :: Vector Word -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word # basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m () # elemseq :: Vector Word -> Word -> b -> b #
Vector Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8) # basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8) # basicLength :: Vector Word8 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8 # basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m () # elemseq :: Vector Word8 -> Word8 -> b -> b #
Vector Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> m (Vector Word16) # basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m (Mutable Vector (PrimState m) Word16) # basicLength :: Vector Word16 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16 # basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> Vector Word16 -> m () # elemseq :: Vector Word16 -> Word16 -> b -> b #
Vector Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> m (Vector Word32) # basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m (Mutable Vector (PrimState m) Word32) # basicLength :: Vector Word32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32 # basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> Vector Word32 -> m () # elemseq :: Vector Word32 -> Word32 -> b -> b #
Vector Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> m (Vector Word64) # basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m (Mutable Vector (PrimState m) Word64) # basicLength :: Vector Word64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64 # basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> Vector Word64 -> m () # elemseq :: Vector Word64 -> Word64 -> b -> b #
Vector Vector ()
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) () -> m (Vector ()) # basicUnsafeThaw :: PrimMonad m => Vector () -> m (Mutable Vector (PrimState m) ()) # basicLength :: Vector () -> Int # basicUnsafeSlice :: Int -> Int -> Vector () -> Vector () # basicUnsafeIndexM :: Monad m => Vector () -> Int -> m () # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) () -> Vector () -> m () # elemseq :: Vector () -> () -> b -> b #
(Vector Vector a, Convertible' Char a) => Convertible Char (Vector a) #
Instance details Defined in Data.Container.Vector Methods convert :: Char -> Vector a #
(Vector Vector a, Convertible' Char a) => Convertible Text (Vector a) #
Instance details Defined in Data.Container.Vector Methods convert :: Text -> Vector a #
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)) # basicUnsafeThaw :: PrimMonad m => Vector (Complex a) -> m (Mutable Vector (PrimState m) (Complex a)) # basicLength :: Vector (Complex a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a) # basicUnsafeIndexM :: Monad m => Vector (Complex a) -> Int -> m (Complex a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> Vector (Complex a) -> m () # elemseq :: Vector (Complex a) -> Complex a -> b -> b #
(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)) # basicUnsafeThaw :: PrimMonad m => Vector (a, b) -> m (Mutable Vector (PrimState m) (a, b)) # basicLength :: Vector (a, b) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b) -> Vector (a, b) # basicUnsafeIndexM :: Monad m => Vector (a, b) -> Int -> m (a, b) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> Vector (a, b) -> m () # elemseq :: Vector (a, b) -> (a, b) -> b0 -> b0 #
(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)) # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c) -> m (Mutable Vector (PrimState m) (a, b, c)) # basicLength :: Vector (a, b, c) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c) -> Vector (a, b, c) # basicUnsafeIndexM :: Monad m => Vector (a, b, c) -> Int -> m (a, b, c) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> Vector (a, b, c) -> m () # 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 :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> m (Vector (a, b, c, d)) # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d) -> m (Mutable Vector (PrimState m) (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 :: Monad m => Vector (a, b, c, d) -> Int -> m (a, b, c, d) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> Vector (a, b, c, d) -> m () # elemseq :: Vector (a, b, c, d) -> (a, b, c, d) -> b0 -> b0 #
(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)) # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e) -> m (Mutable Vector (PrimState m) (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 :: Monad m => Vector (a, b, c, d, e) -> Int -> m (a, b, c, d, e) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> Vector (a, b, c, d, e) -> m () # 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 :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> m (Vector (a, b, c, d, e, f)) # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e, f) -> m (Mutable Vector (PrimState m) (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 :: Monad m => Vector (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> m () # elemseq :: Vector (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> b0 -> b0 #
(Data a, Unbox a) => Data (Vector a)
Instance details Defined in Data.Vector.Unboxed.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) # toConstr :: Vector a -> Constr # dataTypeOf :: Vector a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) # gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #
(Vector Vector a, Convertible' Char a) => IsString (Vector a) #
Instance details Defined in Data.Container.Vector Methods fromString :: String -> Vector a #
NFData (Vector a)
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: Vector a -> () #
Unbox a => Ixed (Vector a)
Instance details Defined in Control.Lens.At Methods ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a)) #
Unbox a => Wrapped (Vector a)
Instance details Defined in Control.Lens.Wrapped Associated Types type Unwrapped (Vector a) :: * # Methods _Wrapped' :: Iso' (Vector a) (Unwrapped (Vector a)) #
(Vector Vector a, Convertible' a Char) => Convertible (Vector a) Text #
Instance details Defined in Data.Container.Vector Methods convert :: Vector a -> Text #
(Unbox a, t ~ Vector a') => Rewrapped (Vector a) t
Instance details Defined in Control.Lens.Wrapped
Vector Vector a => Convertible [a] (Vector a) #
Instance details Defined in Data.Container.Vector Methods convert :: [a] -> Vector a #
(Vector Vector a, Convertible' t a) => Convertible [t] (Vector a) #	We cannot use automatic Convertible1 -> Convertible lifting, because converting unboxed Vectors constraints `a` to be unboxed as well.
Instance details Defined in Data.Container.Vector Methods convert :: [t] -> Vector a #
Vector Vector a => Convertible (Vector a) [a] #
Instance details Defined in Data.Container.Vector Methods convert :: Vector a -> [a] #
(Vector Vector a, Convertible' a t) => Convertible (Vector a) [t] #
Instance details Defined in Data.Container.Vector Methods convert :: Vector a -> [t] #
data Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base data Vector Bool = V_Bool (Vector Word8)
data Vector Char
Instance details Defined in Data.Vector.Unboxed.Base data Vector Char = V_Char (Vector Char)
data Vector Double
Instance details Defined in Data.Vector.Unboxed.Base data Vector Double = V_Double (Vector Double)
data Vector Float
Instance details Defined in Data.Vector.Unboxed.Base data Vector Float = V_Float (Vector Float)
data Vector Int
Instance details Defined in Data.Vector.Unboxed.Base data Vector Int = V_Int (Vector Int)
data Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base data Vector Int8 = V_Int8 (Vector Int8)
data Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base data Vector Int16 = V_Int16 (Vector Int16)
data Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base data Vector Int32 = V_Int32 (Vector Int32)
data Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base data Vector Int64 = V_Int64 (Vector Int64)
data Vector Word
Instance details Defined in Data.Vector.Unboxed.Base data Vector Word = V_Word (Vector Word)
data Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base data Vector Word8 = V_Word8 (Vector Word8)
data Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base data Vector Word16 = V_Word16 (Vector Word16)
data Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base data Vector Word32 = V_Word32 (Vector Word32)
data Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base data Vector Word64 = V_Word64 (Vector Word64)
data Vector ()
Instance details Defined in Data.Vector.Unboxed.Base data 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
data Vector (Complex a)
Instance details Defined in Data.Vector.Unboxed.Base data Vector (Complex a) = V_Complex (Vector (a, a))
type Index (Vector a)
Instance details Defined in Control.Lens.At type Index (Vector a) = Int
type IxValue (Vector a)
Instance details Defined in Control.Lens.At type IxValue (Vector a) = a
type Unwrapped (Vector a)
Instance details Defined in Control.Lens.Wrapped type Unwrapped (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)

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

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

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

O(1) Unzip 6 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) #

O(1) Zip 6 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) #

O(1) Unzip 5 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) #

O(1) Zip 5 vectors

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

O(1) Unzip 4 vectors

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

O(1) Zip 4 vectors

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

O(1) Unzip 3 vectors

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

O(1) Zip 3 vectors

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

O(1) Unzip 2 vectors

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

O(1) Zip 2 vectors

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

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

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

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

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

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

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

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

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

O(1) Unsafely convert an immutable vector to a mutable one without copying. The immutable vector may not be used after this operation.

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

O(1) Unsafe convert a mutable vector to an immutable one without copying. The mutable vector may not be used after this operation.

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

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

fromListN n xs = fromList (take n xs)

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

O(n) Convert a list to a vector

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

O(n) Convert a vector to a list

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

O(n) Right-to-left scan over a non-empty vector with a strict accumulator

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

O(n) Right-to-left scan over a non-empty vector

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

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

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

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

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

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

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

O(n) Right-to-left scan

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

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

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

O(n) Right-to-left prescan

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

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

O(n) Scan over a non-empty vector with a strict accumulator

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

O(n) Scan over a non-empty vector

scanl f <x1,...,xn> = <y1,...,yn>
  where y1 = x1
        yi = f y(i-1) xi

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

O(n) Haskell-style scan with strict accumulator

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

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>

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

O(n) Scan with strict accumulator

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

O(n) Scan

postscanl f z = tail . scanl f z

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

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

O(n) Prescan with strict accumulator

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

O(n) Prescan

prescanl f z = init . scanl f z

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

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

O(n) Monadic fold over non-empty vectors with strict accumulator that discards the result

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

O(n) Monadic fold with strict accumulator 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 () #

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

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

O(n) Monadic fold over non-empty vectors that discards the result

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

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

O(n) Monadic fold that discards the result

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

O(n) Monadic fold over non-empty vectors with strict accumulator

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

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

O(n) Monadic fold with strict accumulator

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

O(n) Monadic fold over non-empty vectors

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

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 #

O(n) Monadic fold

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

O(n) Yield the index of the minimum element of the vector according to the given comparison function. The vector may not be empty.

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

O(n) Yield the index of the minimum element of the vector. The vector may not be empty.

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

O(n) Yield the index of the maximum element of the vector according to the given comparison function. The vector may not be empty.

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

O(n) Yield the index of the maximum element of the vector. The vector may not be empty.

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

O(n) Yield the minimum element of the vector according to the given comparison function. The vector may not be empty.

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

O(n) Yield the minimum element of the vector. The vector may not be empty.

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

O(n) Yield the maximum element of the vector according to the given comparison function. The vector may not be empty.

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

O(n) Yield the maximum element of the vector. The vector may not be empty.

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

O(n) Compute the produce of the elements

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

O(n) Compute the sum of the elements

or :: Vector Bool -> Bool #

O(n) Check if any element is True

and :: Vector Bool -> Bool #

O(n) Check if all elements are True

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

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

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

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

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

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

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

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

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

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

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

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

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

O(n) Right fold on non-empty vectors with strict accumulator

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

O(n) Right fold with a strict accumulator

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

O(n) Right fold on non-empty vectors

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

O(n) Right fold

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

O(n) Left fold on non-empty vectors with strict accumulator

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

O(n) Left fold with strict accumulator

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

O(n) Left fold on non-empty vectors

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

O(n) Left fold

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

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

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

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.

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

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

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

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

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

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

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

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

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

O(n) Check if the vector contains an element

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

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

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

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

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

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.

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

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.

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

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

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

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

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

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

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

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

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

O(n) Drop elements when predicate returns Nothing

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

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 #

O(n) Drop repeated adjacent elements.

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

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

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

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

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

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

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

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

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

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 #

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 #

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 #

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

Zip three vectors and their indices with the given function.

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

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

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 #

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 #

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 #

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

Zip three vectors with the given function.

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

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

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

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

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

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

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

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

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

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

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

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, Unbox b) => (a -> m b) -> Vector a -> m (Vector b) #

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

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

Map a function over a vector and concatenate the results.

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

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

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

O(n) Map a function over a vector

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

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

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

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

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

Same as backpermute but without bounds checking.

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

O(n) Yield the vector obtained by replacing each element i of the index vector by xs!i. This is equivalent to map (xs!) is but is often much more efficient.

backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>

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

O(n) Reverse a vector

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

Same as accumulate_ but without bounds checking.

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

Same as accumulate but without bounds checking.

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

Same as accum but without bounds checking.

accumulate_ #

Arguments

:: (Unbox a, Unbox b)
=> (a -> b -> a)	accumulating function `f`
-> Vector a	initial vector (of length `m`)
-> Vector Int	index vector (of length `n1`)
-> Vector b	value vector (of length `n2`)
-> Vector a

O(m+min(n1,n2)) For each index i from the index vector and the corresponding value b from the the value vector, replace the element of the initial vector at position i by f a b.

accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>

The function accumulate provides the same functionality and is usually more convenient.

accumulate_ f as is bs = accumulate f as (zip is bs)

accumulate #

Arguments

:: (Unbox a, Unbox b)
=> (a -> b -> a)	accumulating function `f`
-> Vector a	initial vector (of length `m`)
-> Vector (Int, b)	vector of index/value pairs (of length `n`)
-> Vector a

O(m+n) For each pair (i,b) from the vector of pairs, replace the vector element a at position i by f a b.

accumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>

accum #

Arguments

:: Unbox a
=> (a -> b -> a)	accumulating function `f`
-> Vector a	initial vector (of length `m`)
-> [(Int, b)]	list of index/value pairs (of length `n`)
-> Vector a

O(m+n) For each pair (i,b) from the list, replace the vector element a at position i by f a b.

accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>

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

Same as update_ but without bounds checking.

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

Same as update but without bounds checking.

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

Same as (//) but without bounds checking.

update_ #

Arguments

:: Unbox a
=> Vector a	initial vector (of length `m`)
-> Vector Int	index vector (of length `n1`)
-> Vector a	value vector (of length `n2`)
-> Vector a

O(m+min(n1,n2)) For each index i from the index vector and the corresponding value a from the value vector, replace the element of the initial vector at position i by a.

update_ <5,9,2,7>  <2,0,2> <1,3,8> = <3,9,8,7>

The function update provides the same functionality and is usually more convenient.

update_ xs is ys = update xs (zip is ys)

update #

Arguments

:: Unbox a
=> Vector a	initial vector (of length `m`)
-> Vector (Int, a)	vector of index/value pairs (of length `n`)
-> Vector a

O(m+n) For each pair (i,a) from the vector of index/value pairs, replace the vector element at position i by a.

update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>

(//) #

Arguments

:: Unbox a
=> Vector a	initial vector (of length `m`)
-> [(Int, a)]	list of index/value pairs (of length `n`)
-> Vector a

O(m+n) For each pair (i,a) from the list, replace the vector element at position i by a.

<5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>

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

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.

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

Execute the monadic action and freeze the resulting vectors.

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

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>

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

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

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

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

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

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

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

O(n) Concatenate all vectors in the list

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

O(m+n) Concatenate two vectors

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

O(n) Append an element

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

O(n) Prepend an element

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

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.

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

O(n) Enumerate values from x to y.

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

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

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>

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

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>

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

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>

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

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>

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

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.

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

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.

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

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>

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

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>

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

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

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

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

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

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

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

O(1) Vector with exactly one element

empty :: Unbox a => Vector a #

O(1) Empty vector

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

O(1) Yield all but the first n elements without copying. The vector must contain at least n elements but this is not checked.

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

O(1) Yield the first n elements without copying. The vector must contain at least n elements but this is not checked.

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

O(1) Yield all but the first element without copying. The vector may not be empty but this is not checked.

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

O(1) Yield all but the last element without copying. The vector may not be empty but this is not checked.

unsafeSlice #

Arguments

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

O(1) Yield a slice of the vector without copying. The vector must contain at least i+n elements but this is not checked.

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

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.

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

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.

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

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.

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

O(1) Yield all but the first element without copying. The vector may not be empty.

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

O(1) Yield all but the last element without copying. The vector may not be empty.

slice #

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.

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

O(1) Last element in a monad without checking for empty vectors. See indexM for an explanation of why this is useful.

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

O(1) First element in a monad without checking for empty vectors. See indexM for an explanation of why this is useful.

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

O(1) Indexing in a monad without bounds checks. See indexM for an explanation of why this is useful.

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

O(1) Last element of a vector in a monad. See indexM for an explanation of why this is useful.

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

O(1) First element of a vector in a monad. See indexM for an explanation of why this is useful.

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

O(1) Indexing in a monad.

The monad allows operations to be strict in the vector when necessary. Suppose vector copying is implemented like this:

copy mv v = ... write mv i (v ! i) ...

For lazy vectors, v ! i would not be evaluated which means that mv would unnecessarily retain a reference to v in each element written.

With indexM, copying can be implemented like this instead:

copy mv v = ... do
                  x <- indexM v i
                  write mv i x

Here, no references to v are retained because indexing (but not the elements) is evaluated eagerly.

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

O(1) Last element without checking if the vector is empty

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

O(1) First element without checking if the vector is empty

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

O(1) Unsafe indexing without bounds checking

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

O(1) Last element

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

O(1) First element

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

O(1) Safe indexing

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

O(1) Indexing

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

O(1) Test whether a vector is empty

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

O(1) Yield the length of the vector

data family MVector s a :: * #

Instances

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 :: PrimMonad m => Int -> m (MVector (PrimState m) Bool) # basicInitialize :: PrimMonad m => MVector (PrimState m) Bool -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Bool -> m (MVector (PrimState m) Bool) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m Bool # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Bool -> Int -> Bool -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Bool -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Bool -> Bool -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) 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 :: PrimMonad m => Int -> m (MVector (PrimState m) Char) # basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Char -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) 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 :: PrimMonad m => Int -> m (MVector (PrimState m) Double) # basicInitialize :: PrimMonad m => MVector (PrimState m) Double -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Double -> m (MVector (PrimState m) Double) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Double -> Int -> m Double # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Double -> Int -> Double -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Double -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Double -> Double -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Double -> MVector (PrimState m) Double -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Double -> Int -> m (MVector (PrimState m) 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 :: PrimMonad m => Int -> m (MVector (PrimState m) Float) # basicInitialize :: PrimMonad m => MVector (PrimState m) Float -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Float -> m (MVector (PrimState m) Float) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Float -> Int -> m Float # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Float -> Int -> Float -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Float -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Float -> Float -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Float -> MVector (PrimState m) Float -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Float -> Int -> m (MVector (PrimState m) 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 :: PrimMonad m => Int -> m (MVector (PrimState m) Int) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int -> m (MVector (PrimState m) Int) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int -> Int -> m Int # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int -> Int -> Int -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int -> Int -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int -> MVector (PrimState m) Int -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int -> Int -> m (MVector (PrimState m) Int) #
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 :: PrimMonad m => Int -> m (MVector (PrimState m) Int8) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int8 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int8 -> m (MVector (PrimState m) Int8) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m Int8 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> Int8 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int8 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int8 -> Int8 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int8 -> MVector (PrimState m) Int8 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int8 -> Int -> m (MVector (PrimState m) Int8) #
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 :: PrimMonad m => Int -> m (MVector (PrimState m) Int16) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int16 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int16 -> m (MVector (PrimState m) Int16) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m Int16 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> Int16 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int16 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int16 -> Int16 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int16 -> MVector (PrimState m) Int16 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int16 -> Int -> m (MVector (PrimState m) 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 :: PrimMonad m => Int -> m (MVector (PrimState m) Int32) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int32 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int32 -> m (MVector (PrimState m) Int32) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m Int32 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> Int32 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int32 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int32 -> Int32 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int32 -> MVector (PrimState m) Int32 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int32 -> Int -> m (MVector (PrimState m) 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 :: PrimMonad m => Int -> m (MVector (PrimState m) Int64) # basicInitialize :: PrimMonad m => MVector (PrimState m) Int64 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Int64 -> m (MVector (PrimState m) Int64) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m Int64 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> Int64 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Int64 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Int64 -> Int64 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Int64 -> MVector (PrimState m) Int64 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Int64 -> Int -> m (MVector (PrimState m) Int64) #
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 :: PrimMonad m => Int -> m (MVector (PrimState m) Word) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word -> m (MVector (PrimState m) Word) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word -> Int -> m Word # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word -> Int -> Word -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word -> Word -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word -> MVector (PrimState m) Word -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word -> Int -> m (MVector (PrimState m) Word) #
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 :: PrimMonad m => Int -> m (MVector (PrimState m) Word8) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word8 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word8 -> m (MVector (PrimState m) Word8) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m Word8 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> Word8 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word8 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word8 -> Word8 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word8 -> Int -> m (MVector (PrimState m) Word8) #
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 :: PrimMonad m => Int -> m (MVector (PrimState m) Word16) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word16 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word16 -> m (MVector (PrimState m) Word16) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m Word16 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> Word16 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word16 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word16 -> Word16 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word16 -> MVector (PrimState m) Word16 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word16 -> Int -> m (MVector (PrimState m) 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 :: PrimMonad m => Int -> m (MVector (PrimState m) Word32) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word32 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word32 -> m (MVector (PrimState m) Word32) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m Word32 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> Word32 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word32 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word32 -> Word32 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word32 -> MVector (PrimState m) Word32 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word32 -> Int -> m (MVector (PrimState m) 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 :: PrimMonad m => Int -> m (MVector (PrimState m) Word64) # basicInitialize :: PrimMonad m => MVector (PrimState m) Word64 -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Word64 -> m (MVector (PrimState m) Word64) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m Word64 # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> Word64 -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Word64 -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Word64 -> Word64 -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Word64 -> MVector (PrimState m) Word64 -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Word64 -> Int -> m (MVector (PrimState m) Word64) #
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 :: PrimMonad m => Int -> m (MVector (PrimState m) ()) # basicInitialize :: PrimMonad m => MVector (PrimState m) () -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> () -> m (MVector (PrimState m) ()) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) () -> Int -> m () # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) () -> Int -> () -> m () # basicClear :: PrimMonad m => MVector (PrimState m) () -> m () # basicSet :: PrimMonad m => MVector (PrimState m) () -> () -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) () -> MVector (PrimState m) () -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) () -> Int -> m (MVector (PrimState m) ()) #
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 :: PrimMonad m => Int -> m (MVector (PrimState m) (Complex a)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (Complex a) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Complex a -> m (MVector (PrimState m) (Complex a)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (Complex a) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> Complex a -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (Complex a) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (Complex a) -> Complex a -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (MVector (PrimState m) (Complex a)) #
(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 :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> (a, b) -> m (MVector (PrimState m) (a, b)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> m (a, b) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> (a, b) -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (a, b) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (a, b) -> (a, b) -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b) -> MVector (PrimState m) (a, b) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b) -> MVector (PrimState m) (a, b) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b) -> Int -> m (MVector (PrimState m) (a, b)) #
(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 :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c) -> m (MVector (PrimState m) (a, b, c)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (a, b, c) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> (a, b, c) -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c) -> (a, b, c) -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c) -> MVector (PrimState m) (a, b, c) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c) -> Int -> m (MVector (PrimState m) (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 :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d) -> m (MVector (PrimState m) (a, b, c, d)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (a, b, c, d) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> (a, b, c, d) -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> (a, b, c, d) -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> MVector (PrimState m) (a, b, c, d) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d) -> Int -> m (MVector (PrimState m) (a, b, c, d)) #
(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 :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e) -> m (MVector (PrimState m) (a, b, c, d, e)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (a, b, c, d, e) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> (a, b, c, d, e) -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> (a, b, c, d, e) -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> MVector (PrimState m) (a, b, c, d, e) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e) -> Int -> m (MVector (PrimState m) (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 :: PrimMonad m => Int -> m (MVector (PrimState m) (a, b, c, d, e, f)) # basicInitialize :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> (a, b, c, d, e, f) -> m (MVector (PrimState m) (a, b, c, d, e, f)) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f) # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> (a, b, c, d, e, f) -> m () # basicClear :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> m () # basicSet :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> MVector (PrimState m) (a, b, c, d, e, f) -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a, b, c, d, e, f) -> Int -> m (MVector (PrimState m) (a, b, c, d, e, f)) #
NFData (MVector s a)
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: MVector s a -> () #
data MVector s Bool
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Bool = MV_Bool (MVector s Word8)
data MVector s Char
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Char = MV_Char (MVector s Char)
data MVector s Double
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Double = MV_Double (MVector s Double)
data MVector s Float
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Float = MV_Float (MVector s Float)
data MVector s Word64
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Word64 = MV_Word64 (MVector s Word64)
data MVector s Word32
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Word32 = MV_Word32 (MVector s Word32)
data MVector s Word16
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Word16 = MV_Word16 (MVector s Word16)
data MVector s Word8
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Word8 = MV_Word8 (MVector s Word8)
data MVector s Word
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Word = MV_Word (MVector s Word)
data MVector s Int64
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Int64 = MV_Int64 (MVector s Int64)
data MVector s Int32
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Int32 = MV_Int32 (MVector s Int32)
data MVector s Int16
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Int16 = MV_Int16 (MVector s Int16)
data MVector s Int8
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Int8 = MV_Int8 (MVector s Int8)
data MVector s Int
Instance details Defined in Data.Vector.Unboxed.Base data MVector s Int = MV_Int (MVector s Int)
data MVector s ()
Instance details Defined in Data.Vector.Unboxed.Base data MVector s () = MV_Unit Int
data MVector s (Complex a)
Instance details Defined in Data.Vector.Unboxed.Base data 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)

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

O(n) Convert different vector types

index :: Vector v a => v a -> Int -> Maybe a Source #

O(1)

replace :: (Vector v a, Eq a) => a -> v a -> v a -> v a Source #

O(n)

commonPrefixes :: (Vector v a, Eq a) => v a -> v a -> Maybe (v a, v a, v a) Source #