Safe Haskell	None
Language	Haskell2010

Data.Vector.Unboxing

Contents

Accessors
Construction
Modifying vectors
Elementwise operations
Working with predicates
Folding
- Specialised folds
- Monadic folds
Prefix sums (scans)
Conversions

Synopsis

data Vector a
class Unbox (Rep a) => Unboxable a where
- type Rep a
newtype Generics a = Generics a
length :: Unboxable a => Vector a -> Int
null :: Unboxable a => Vector a -> Bool
(!) :: Unboxable a => Vector a -> Int -> a
(!?) :: Unboxable a => Vector a -> Int -> Maybe a
head :: Unboxable a => Vector a -> a
last :: Unboxable a => Vector a -> a
unsafeIndex :: Unboxable a => Vector a -> Int -> a
unsafeHead :: Unboxable a => Vector a -> a
unsafeLast :: Unboxable a => Vector a -> a
indexM :: (Monad m, Unboxable a) => Vector a -> Int -> m a
headM :: (Monad m, Unboxable a) => Vector a -> m a
lastM :: (Monad m, Unboxable a) => Vector a -> m a
unsafeIndexM :: (Monad m, Unboxable a) => Vector a -> Int -> m a
unsafeHeadM :: (Monad m, Unboxable a) => Vector a -> m a
unsafeLastM :: (Monad m, Unboxable a) => Vector a -> m a
slice :: Unboxable a => Int -> Int -> Vector a -> Vector a
init :: Unboxable a => Vector a -> Vector a
tail :: Unboxable a => Vector a -> Vector a
take :: Unboxable a => Int -> Vector a -> Vector a
drop :: Unboxable a => Int -> Vector a -> Vector a
splitAt :: Unboxable a => Int -> Vector a -> (Vector a, Vector a)
unsafeSlice :: Unboxable a => Int -> Int -> Vector a -> Vector a
unsafeInit :: Unboxable a => Vector a -> Vector a
unsafeTail :: Unboxable a => Vector a -> Vector a
unsafeTake :: Unboxable a => Int -> Vector a -> Vector a
unsafeDrop :: Unboxable a => Int -> Vector a -> Vector a
empty :: Unboxable a => Vector a
singleton :: Unboxable a => a -> Vector a
replicate :: Unboxable a => Int -> a -> Vector a
generate :: Unboxable a => Int -> (Int -> a) -> Vector a
iterateN :: Unboxable a => Int -> (a -> a) -> a -> Vector a
replicateM :: (Monad m, Unboxable a) => Int -> m a -> m (Vector a)
generateM :: (Monad m, Unboxable a) => Int -> (Int -> m a) -> m (Vector a)
iterateNM :: (Monad m, Unboxable a) => Int -> (a -> m a) -> a -> m (Vector a)
create :: Unboxable a => (forall s. ST s (MVector s a)) -> Vector a
createT :: (Traversable f, Unboxable a) => (forall s. ST s (f (MVector s a))) -> f (Vector a)
unfoldr :: Unboxable a => (b -> Maybe (a, b)) -> b -> Vector a
unfoldrN :: Unboxable a => Int -> (b -> Maybe (a, b)) -> b -> Vector a
unfoldrM :: (Monad m, Unboxable a) => (b -> m (Maybe (a, b))) -> b -> m (Vector a)
unfoldrNM :: (Monad m, Unboxable a) => Int -> (b -> m (Maybe (a, b))) -> b -> m (Vector a)
constructN :: Unboxable a => Int -> (Vector a -> a) -> Vector a
constructrN :: Unboxable a => Int -> (Vector a -> a) -> Vector a
enumFromN :: (Num a, Unboxable a) => a -> Int -> Vector a
enumFromStepN :: (Num a, Unboxable a) => a -> a -> Int -> Vector a
enumFromTo :: (Enum a, Unboxable a) => a -> a -> Vector a
enumFromThenTo :: (Enum a, Unboxable a) => a -> a -> a -> Vector a
cons :: Unboxable a => a -> Vector a -> Vector a
snoc :: Unboxable a => Vector a -> a -> Vector a
(++) :: Unboxable a => Vector a -> Vector a -> Vector a
concat :: Unboxable a => [Vector a] -> Vector a
force :: Unboxable a => Vector a -> Vector a
(//) :: Unboxable a => Vector a -> [(Int, a)] -> Vector a
update :: Unboxable a => Vector a -> Vector (Int, a) -> Vector a
update_ :: Unboxable a => Vector a -> Vector Int -> Vector a -> Vector a
unsafeUpd :: Unboxable a => Vector a -> [(Int, a)] -> Vector a
unsafeUpdate :: Unboxable a => Vector a -> Vector (Int, a) -> Vector a
unsafeUpdate_ :: Unboxable a => Vector a -> Vector Int -> Vector a -> Vector a
accum :: Unboxable a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
accumulate :: (Unboxable a, Unboxable b) => (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
accumulate_ :: (Unboxable a, Unboxable b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
unsafeAccum :: Unboxable a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
unsafeAccumulate :: (Unboxable a, Unboxable b) => (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
unsafeAccumulate_ :: (Unboxable a, Unboxable b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
reverse :: Unboxable a => Vector a -> Vector a
backpermute :: Unboxable a => Vector a -> Vector Int -> Vector a
unsafeBackpermute :: Unboxable a => Vector a -> Vector Int -> Vector a
modify :: Unboxable a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
indexed :: Unboxable a => Vector a -> Vector (Int, a)
map :: (Unboxable a, Unboxable b) => (a -> b) -> Vector a -> Vector b
imap :: (Unboxable a, Unboxable b) => (Int -> a -> b) -> Vector a -> Vector b
concatMap :: (Unboxable a, Unboxable b) => (a -> Vector b) -> Vector a -> Vector b
mapM :: (Monad m, Unboxable a, Unboxable b) => (a -> m b) -> Vector a -> m (Vector b)
imapM :: (Monad m, Unboxable a, Unboxable b) => (Int -> a -> m b) -> Vector a -> m (Vector b)
mapM_ :: (Monad m, Unboxable a) => (a -> m b) -> Vector a -> m ()
imapM_ :: (Monad m, Unboxable a) => (Int -> a -> m b) -> Vector a -> m ()
forM :: (Monad m, Unboxable a, Unboxable b) => Vector a -> (a -> m b) -> m (Vector b)
forM_ :: (Monad m, Unboxable a) => Vector a -> (a -> m b) -> m ()
zipWith :: (Unboxable a, Unboxable b, Unboxable c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c
zipWith3 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d) => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
zipWith4 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e) => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
zipWith5 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e, Unboxable f) => (a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
zipWith6 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e, Unboxable f, Unboxable g) => (a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
izipWith :: (Unboxable a, Unboxable b, Unboxable c) => (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
izipWith3 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d) => (Int -> a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
izipWith4 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e) => (Int -> a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
izipWith5 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e, Unboxable f) => (Int -> a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
izipWith6 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e, Unboxable f, Unboxable g) => (Int -> a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
zip :: (Unboxable a, Unboxable b) => Vector a -> Vector b -> Vector (a, b)
zip3 :: (Unboxable a, Unboxable b, Unboxable c) => Vector a -> Vector b -> Vector c -> Vector (a, b, c)
zip4 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d) => Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)
zip5 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)
zip6 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e, Unboxable f) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector (a, b, c, d, e, f)
zipWithM :: (Monad m, Unboxable a, Unboxable b, Unboxable c) => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
izipWithM :: (Monad m, Unboxable a, Unboxable b, Unboxable c) => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
zipWithM_ :: (Monad m, Unboxable a, Unboxable b) => (a -> b -> m c) -> Vector a -> Vector b -> m ()
izipWithM_ :: (Monad m, Unboxable a, Unboxable b) => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m ()
unzip :: (Unboxable a, Unboxable b) => Vector (a, b) -> (Vector a, Vector b)
unzip3 :: (Unboxable a, Unboxable b, Unboxable c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
unzip4 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d) => Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)
unzip5 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e) => Vector (a, b, c, d, e) -> (Vector a, Vector b, Vector c, Vector d, Vector e)
unzip6 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e, Unboxable f) => Vector (a, b, c, d, e, f) -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
filter :: Unboxable a => (a -> Bool) -> Vector a -> Vector a
ifilter :: Unboxable a => (Int -> a -> Bool) -> Vector a -> Vector a
uniq :: (Eq a, Unboxable a) => Vector a -> Vector a
mapMaybe :: (Unboxable a, Unboxable b) => (a -> Maybe b) -> Vector a -> Vector b
imapMaybe :: (Unboxable a, Unboxable b) => (Int -> a -> Maybe b) -> Vector a -> Vector b
filterM :: (Monad m, Unboxable a) => (a -> m Bool) -> Vector a -> m (Vector a)
takeWhile :: Unboxable a => (a -> Bool) -> Vector a -> Vector a
dropWhile :: Unboxable a => (a -> Bool) -> Vector a -> Vector a
partition :: Unboxable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
unstablePartition :: Unboxable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
span :: Unboxable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
break :: Unboxable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
elem :: (Eq a, Unboxable a) => a -> Vector a -> Bool
notElem :: (Eq a, Unboxable a) => a -> Vector a -> Bool
find :: Unboxable a => (a -> Bool) -> Vector a -> Maybe a
findIndex :: Unboxable a => (a -> Bool) -> Vector a -> Maybe Int
findIndices :: Unboxable a => (a -> Bool) -> Vector a -> Vector Int
elemIndex :: (Eq a, Unboxable a) => a -> Vector a -> Maybe Int
elemIndices :: (Eq a, Unboxable a) => a -> Vector a -> Vector Int
foldl :: Unboxable b => (a -> b -> a) -> a -> Vector b -> a
foldl1 :: Unboxable a => (a -> a -> a) -> Vector a -> a
foldl' :: Unboxable b => (a -> b -> a) -> a -> Vector b -> a
foldl1' :: Unboxable a => (a -> a -> a) -> Vector a -> a
foldr :: Unboxable a => (a -> b -> b) -> b -> Vector a -> b
foldr1 :: Unboxable a => (a -> a -> a) -> Vector a -> a
foldr' :: Unboxable a => (a -> b -> b) -> b -> Vector a -> b
foldr1' :: Unboxable a => (a -> a -> a) -> Vector a -> a
ifoldl :: Unboxable b => (a -> Int -> b -> a) -> a -> Vector b -> a
ifoldl' :: Unboxable b => (a -> Int -> b -> a) -> a -> Vector b -> a
ifoldr :: Unboxable a => (Int -> a -> b -> b) -> b -> Vector a -> b
ifoldr' :: Unboxable a => (Int -> a -> b -> b) -> b -> Vector a -> b
all :: Unboxable a => (a -> Bool) -> Vector a -> Bool
any :: Unboxable a => (a -> Bool) -> Vector a -> Bool
and :: Vector Bool -> Bool
or :: Vector Bool -> Bool
sum :: (Num a, Unboxable a) => Vector a -> a
product :: (Num a, Unboxable a) => Vector a -> a
maximum :: (Ord a, Unboxable a) => Vector a -> a
maximumBy :: Unboxable a => (a -> a -> Ordering) -> Vector a -> a
minimum :: (Ord a, Unboxable a) => Vector a -> a
minimumBy :: Unboxable a => (a -> a -> Ordering) -> Vector a -> a
minIndex :: (Ord a, Unboxable a) => Vector a -> Int
minIndexBy :: Unboxable a => (a -> a -> Ordering) -> Vector a -> Int
maxIndex :: (Ord a, Unboxable a) => Vector a -> Int
maxIndexBy :: Unboxable a => (a -> a -> Ordering) -> Vector a -> Int
foldM :: (Monad m, Unboxable b) => (a -> b -> m a) -> a -> Vector b -> m a
ifoldM :: (Monad m, Unboxable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
foldM' :: (Monad m, Unboxable b) => (a -> b -> m a) -> a -> Vector b -> m a
ifoldM' :: (Monad m, Unboxable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m a
fold1M :: (Monad m, Unboxable a) => (a -> a -> m a) -> Vector a -> m a
fold1M' :: (Monad m, Unboxable a) => (a -> a -> m a) -> Vector a -> m a
foldM_ :: (Monad m, Unboxable b) => (a -> b -> m a) -> a -> Vector b -> m ()
ifoldM_ :: (Monad m, Unboxable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
foldM'_ :: (Monad m, Unboxable b) => (a -> b -> m a) -> a -> Vector b -> m ()
ifoldM'_ :: (Monad m, Unboxable b) => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
fold1M_ :: (Monad m, Unboxable a) => (a -> a -> m a) -> Vector a -> m ()
fold1M'_ :: (Monad m, Unboxable a) => (a -> a -> m a) -> Vector a -> m ()
prescanl :: (Unboxable a, Unboxable b) => (a -> b -> a) -> a -> Vector b -> Vector a
prescanl' :: (Unboxable a, Unboxable b) => (a -> b -> a) -> a -> Vector b -> Vector a
postscanl :: (Unboxable a, Unboxable b) => (a -> b -> a) -> a -> Vector b -> Vector a
postscanl' :: (Unboxable a, Unboxable b) => (a -> b -> a) -> a -> Vector b -> Vector a
scanl :: (Unboxable a, Unboxable b) => (a -> b -> a) -> a -> Vector b -> Vector a
scanl' :: (Unboxable a, Unboxable b) => (a -> b -> a) -> a -> Vector b -> Vector a
scanl1 :: Unboxable a => (a -> a -> a) -> Vector a -> Vector a
scanl1' :: Unboxable a => (a -> a -> a) -> Vector a -> Vector a
iscanl :: (Unboxable a, Unboxable b) => (Int -> a -> b -> a) -> a -> Vector b -> Vector a
iscanl' :: (Unboxable a, Unboxable b) => (Int -> a -> b -> a) -> a -> Vector b -> Vector a
prescanr :: (Unboxable a, Unboxable b) => (a -> b -> b) -> b -> Vector a -> Vector b
prescanr' :: (Unboxable a, Unboxable b) => (a -> b -> b) -> b -> Vector a -> Vector b
postscanr :: (Unboxable a, Unboxable b) => (a -> b -> b) -> b -> Vector a -> Vector b
postscanr' :: (Unboxable a, Unboxable b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanr :: (Unboxable a, Unboxable b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanr' :: (Unboxable a, Unboxable b) => (a -> b -> b) -> b -> Vector a -> Vector b
scanr1 :: Unboxable a => (a -> a -> a) -> Vector a -> Vector a
scanr1' :: Unboxable a => (a -> a -> a) -> Vector a -> Vector a
iscanr :: (Unboxable a, Unboxable b) => (Int -> a -> b -> b) -> b -> Vector a -> Vector b
iscanr' :: (Unboxable a, Unboxable b) => (Int -> a -> b -> b) -> b -> Vector a -> Vector b
toList :: Unboxable a => Vector a -> [a]
fromList :: Unboxable a => [a] -> Vector a
fromListN :: Unboxable a => Int -> [a] -> Vector a
convert :: (Vector v a, Vector w a) => v a -> w a
toUnboxedVector :: (Unboxable a, Rep a ~ a, IsTrivial a ~ True) => Vector a -> Vector a
fromUnboxedVector :: (Unboxable a, Rep a ~ a, IsTrivial a ~ True) => Vector a -> Vector a
coerceVector :: (Coercible a b, Unboxable a, Unboxable b, CoercibleRep a ~ CoercibleRep b, Rep a ~ Rep b) => Vector a -> Vector b
liftCoercion :: (Unboxable a, Unboxable b, CoercibleRep a ~ CoercibleRep b, Rep a ~ Rep b) => Coercion a b -> Coercion (Vector a) (Vector b)
vectorCoercion :: (Coercible a b, Unboxable a, Unboxable b, CoercibleRep a ~ CoercibleRep b, Rep a ~ Rep b) => Coercion (Vector a) (Vector b)
freeze :: (PrimMonad m, Unboxable a) => MVector (PrimState m) a -> m (Vector a)
thaw :: (PrimMonad m, Unboxable a) => Vector a -> m (MVector (PrimState m) a)
copy :: (PrimMonad m, Unboxable a) => MVector (PrimState m) a -> Vector a -> m ()
unsafeFreeze :: (PrimMonad m, Unboxable a) => MVector (PrimState m) a -> m (Vector a)
unsafeThaw :: (PrimMonad m, Unboxable a) => Vector a -> m (MVector (PrimState m) a)
unsafeCopy :: (PrimMonad m, Unboxable a) => MVector (PrimState m) a -> Vector a -> m ()

Documentation

data Vector a Source #

Instances

Unboxable a => Vector Vector a Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) a -> m (Vector a) # basicUnsafeThaw :: PrimMonad m => Vector a -> m (Mutable Vector (PrimState m) a) # basicLength :: Vector a -> Int # basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a # basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) a -> Vector a -> m () # elemseq :: Vector a -> a -> b -> b #
Unboxable a => IsList (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Item (Vector a) :: Type # Methods fromList :: [Item (Vector a)] -> Vector a # fromListN :: Int -> [Item (Vector a)] -> Vector a # toList :: Vector a -> [Item (Vector a)] #
(Eq a, Unboxable a) => Eq (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods (==) :: Vector a -> Vector a -> Bool # (/=) :: Vector a -> Vector a -> Bool #
(Ord a, Unboxable a) => Ord (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods compare :: Vector a -> Vector a -> Ordering # (<) :: Vector a -> Vector a -> Bool # (<=) :: Vector a -> Vector a -> Bool # (>) :: Vector a -> Vector a -> Bool # (>=) :: Vector a -> Vector a -> Bool # max :: Vector a -> Vector a -> Vector a # min :: Vector a -> Vector a -> Vector a #
(Read a, Unboxable a) => Read (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods readsPrec :: Int -> ReadS (Vector a) # readList :: ReadS [Vector a] # readPrec :: ReadPrec (Vector a) # readListPrec :: ReadPrec [Vector a] #
(Show a, Unboxable a) => Show (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods showsPrec :: Int -> Vector a -> ShowS # show :: Vector a -> String # showList :: [Vector a] -> ShowS #
Unboxable a => Semigroup (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods (<>) :: Vector a -> Vector a -> Vector a # sconcat :: NonEmpty (Vector a) -> Vector a # stimes :: Integral b => b -> Vector a -> Vector a #
Unboxable a => Monoid (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
NFData (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods rnf :: Vector a -> () #
Unboxable a => SemiSequence (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Index (Vector a) :: Type # Methods intersperse :: Element (Vector a) -> Vector a -> Vector a # reverse :: Vector a -> Vector a # find :: (Element (Vector a) -> Bool) -> Vector a -> Maybe (Element (Vector a)) # sortBy :: (Element (Vector a) -> Element (Vector a) -> Ordering) -> Vector a -> Vector a # cons :: Element (Vector a) -> Vector a -> Vector a # snoc :: Vector a -> Element (Vector a) -> Vector a #
Unboxable a => IsSequence (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods fromList :: [Element (Vector a)] -> Vector a # lengthIndex :: Vector a -> Index (Vector a) # break :: (Element (Vector a) -> Bool) -> Vector a -> (Vector a, Vector a) # span :: (Element (Vector a) -> Bool) -> Vector a -> (Vector a, Vector a) # dropWhile :: (Element (Vector a) -> Bool) -> Vector a -> Vector a # takeWhile :: (Element (Vector a) -> Bool) -> Vector a -> Vector a # splitAt :: Index (Vector a) -> Vector a -> (Vector a, Vector a) # unsafeSplitAt :: Index (Vector a) -> Vector a -> (Vector a, Vector a) # take :: Index (Vector a) -> Vector a -> Vector a # unsafeTake :: Index (Vector a) -> Vector a -> Vector a # drop :: Index (Vector a) -> Vector a -> Vector a # unsafeDrop :: Index (Vector a) -> Vector a -> Vector a # dropEnd :: Index (Vector a) -> Vector a -> Vector a # partition :: (Element (Vector a) -> Bool) -> Vector a -> (Vector a, Vector a) # uncons :: Vector a -> Maybe (Element (Vector a), Vector a) # unsnoc :: Vector a -> Maybe (Vector a, Element (Vector a)) # filter :: (Element (Vector a) -> Bool) -> Vector a -> Vector a # filterM :: Monad m => (Element (Vector a) -> m Bool) -> Vector a -> m (Vector a) # replicate :: Index (Vector a) -> Element (Vector a) -> Vector a # replicateM :: Monad m => Index (Vector a) -> m (Element (Vector a)) -> m (Vector a) # groupBy :: (Element (Vector a) -> Element (Vector a) -> Bool) -> Vector a -> [Vector a] # groupAllOn :: Eq b => (Element (Vector a) -> b) -> Vector a -> [Vector a] # subsequences :: Vector a -> [Vector a] # permutations :: Vector a -> [Vector a] # tailEx :: Vector a -> Vector a # tailMay :: Vector a -> Maybe (Vector a) # initEx :: Vector a -> Vector a # initMay :: Vector a -> Maybe (Vector a) # unsafeTail :: Vector a -> Vector a # unsafeInit :: Vector a -> Vector a # index :: Vector a -> Index (Vector a) -> Maybe (Element (Vector a)) # indexEx :: Vector a -> Index (Vector a) -> Element (Vector a) # unsafeIndex :: Vector a -> Index (Vector a) -> Element (Vector a) # splitWhen :: (Element (Vector a) -> Bool) -> Vector a -> [Vector a] #
Unboxable a => MonoFunctor (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods omap :: (Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a #
Unboxable a => MonoFoldable (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods ofoldMap :: Monoid m => (Element (Vector a) -> m) -> Vector a -> m # ofoldr :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b # ofoldl' :: (a0 -> Element (Vector a) -> a0) -> a0 -> Vector a -> a0 # otoList :: Vector a -> [Element (Vector a)] # oall :: (Element (Vector a) -> Bool) -> Vector a -> Bool # oany :: (Element (Vector a) -> Bool) -> Vector a -> Bool # onull :: Vector a -> Bool # olength :: Vector a -> Int # olength64 :: Vector a -> Int64 # ocompareLength :: Integral i => Vector a -> i -> Ordering # otraverse_ :: Applicative f => (Element (Vector a) -> f b) -> Vector a -> f () # ofor_ :: Applicative f => Vector a -> (Element (Vector a) -> f b) -> f () # omapM_ :: Applicative m => (Element (Vector a) -> m ()) -> Vector a -> m () # oforM_ :: Applicative m => Vector a -> (Element (Vector a) -> m ()) -> m () # ofoldlM :: Monad m => (a0 -> Element (Vector a) -> m a0) -> a0 -> Vector a -> m a0 # ofoldMap1Ex :: Semigroup m => (Element (Vector a) -> m) -> Vector a -> m # ofoldr1Ex :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Element (Vector a) # ofoldl1Ex' :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Element (Vector a) # headEx :: Vector a -> Element (Vector a) # lastEx :: Vector a -> Element (Vector a) # unsafeHead :: Vector a -> Element (Vector a) # unsafeLast :: Vector a -> Element (Vector a) # maximumByEx :: (Element (Vector a) -> Element (Vector a) -> Ordering) -> Vector a -> Element (Vector a) # minimumByEx :: (Element (Vector a) -> Element (Vector a) -> Ordering) -> Vector a -> Element (Vector a) # oelem :: Element (Vector a) -> Vector a -> Bool # onotElem :: Element (Vector a) -> Vector a -> Bool #
Unboxable a => MonoTraversable (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods otraverse :: Applicative f => (Element (Vector a) -> f (Element (Vector a))) -> Vector a -> f (Vector a) # omapM :: Applicative m => (Element (Vector a) -> m (Element (Vector a))) -> Vector a -> m (Vector a) #
Unboxable a => MonoPointed (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Methods opoint :: Element (Vector a) -> Vector a #
Unboxable a => GrowingAppend (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal
type Mutable Vector Source #
Instance details Defined in Data.Vector.Unboxing.Internal type Mutable Vector = MVector
type Item (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal type Item (Vector a) = a
type Index (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal type Index (Vector a) = Int
type Element (Vector a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal type Element (Vector a) = a

class Unbox (Rep a) => Unboxable a Source #

Types that can be stored in unboxed vectors (Vector and MVector).

You can define instances of this class like:

newtype Foo = Foo Int
instance Unboxable Foo where
  type Rep Foo = Int

The type specified by Rep needs to be an instance of Unbox, and coercion must be possible between the two types.

Instances can also be derived with GeneralizedNewtypeDeriving. GND always works if the base type is an instance of Unboxable.

If you want to have non-trivial correspondence between the type and the representation, use Generics wrapper with DerivingVia.

Note that UndecidableInstances is needed if you use GND or DerivingVia to derive instances.

Associated Types

type Rep a Source #

The underlying type of a. Must be an instance of Unbox.

Instances

Unboxable Bool Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Bool :: Type Source # type CoercibleRep Bool :: Type type IsTrivial Bool :: Bool Methods unboxingFrom :: Bool -> Rep Bool unboxingTo :: Rep Bool -> Bool
Unboxable Char Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Char :: Type Source # type CoercibleRep Char :: Type type IsTrivial Char :: Bool Methods unboxingFrom :: Char -> Rep Char unboxingTo :: Rep Char -> Char
Unboxable Double Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Double :: Type Source # type CoercibleRep Double :: Type type IsTrivial Double :: Bool Methods unboxingFrom :: Double -> Rep Double unboxingTo :: Rep Double -> Double
Unboxable Float Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Float :: Type Source # type CoercibleRep Float :: Type type IsTrivial Float :: Bool Methods unboxingFrom :: Float -> Rep Float unboxingTo :: Rep Float -> Float
Unboxable Int Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Int :: Type Source # type CoercibleRep Int :: Type type IsTrivial Int :: Bool Methods unboxingFrom :: Int -> Rep Int unboxingTo :: Rep Int -> Int
Unboxable Int8 Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Int8 :: Type Source # type CoercibleRep Int8 :: Type type IsTrivial Int8 :: Bool Methods unboxingFrom :: Int8 -> Rep Int8 unboxingTo :: Rep Int8 -> Int8
Unboxable Int16 Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Int16 :: Type Source # type CoercibleRep Int16 :: Type type IsTrivial Int16 :: Bool Methods unboxingFrom :: Int16 -> Rep Int16 unboxingTo :: Rep Int16 -> Int16
Unboxable Int32 Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Int32 :: Type Source # type CoercibleRep Int32 :: Type type IsTrivial Int32 :: Bool Methods unboxingFrom :: Int32 -> Rep Int32 unboxingTo :: Rep Int32 -> Int32
Unboxable Int64 Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Int64 :: Type Source # type CoercibleRep Int64 :: Type type IsTrivial Int64 :: Bool Methods unboxingFrom :: Int64 -> Rep Int64 unboxingTo :: Rep Int64 -> Int64
Unboxable Word Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Word :: Type Source # type CoercibleRep Word :: Type type IsTrivial Word :: Bool Methods unboxingFrom :: Word -> Rep Word unboxingTo :: Rep Word -> Word
Unboxable Word8 Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Word8 :: Type Source # type CoercibleRep Word8 :: Type type IsTrivial Word8 :: Bool Methods unboxingFrom :: Word8 -> Rep Word8 unboxingTo :: Rep Word8 -> Word8
Unboxable Word16 Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Word16 :: Type Source # type CoercibleRep Word16 :: Type type IsTrivial Word16 :: Bool Methods unboxingFrom :: Word16 -> Rep Word16 unboxingTo :: Rep Word16 -> Word16
Unboxable Word32 Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Word32 :: Type Source # type CoercibleRep Word32 :: Type type IsTrivial Word32 :: Bool Methods unboxingFrom :: Word32 -> Rep Word32 unboxingTo :: Rep Word32 -> Word32
Unboxable Word64 Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Word64 :: Type Source # type CoercibleRep Word64 :: Type type IsTrivial Word64 :: Bool Methods unboxingFrom :: Word64 -> Rep Word64 unboxingTo :: Rep Word64 -> Word64
Unboxable () Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep () :: Type Source # type CoercibleRep () :: Type type IsTrivial () :: Bool Methods unboxingFrom :: () -> Rep () unboxingTo :: Rep () -> ()
Unboxable All Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep All :: Type Source # type CoercibleRep All :: Type type IsTrivial All :: Bool Methods unboxingFrom :: All -> Rep All unboxingTo :: Rep All -> All
Unboxable Any Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep Any :: Type Source # type CoercibleRep Any :: Type type IsTrivial Any :: Bool Methods unboxingFrom :: Any -> Rep Any unboxingTo :: Rep Any -> Any
Unboxable a => Unboxable (Complex a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Complex a) :: Type Source # type CoercibleRep (Complex a) :: Type type IsTrivial (Complex a) :: Bool Methods unboxingFrom :: Complex a -> Rep (Complex a) unboxingTo :: Rep (Complex a) -> Complex a
Unboxable a => Unboxable (Min a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Min a) :: Type Source # type CoercibleRep (Min a) :: Type type IsTrivial (Min a) :: Bool Methods unboxingFrom :: Min a -> Rep (Min a) unboxingTo :: Rep (Min a) -> Min a
Unboxable a => Unboxable (Max a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Max a) :: Type Source # type CoercibleRep (Max a) :: Type type IsTrivial (Max a) :: Bool Methods unboxingFrom :: Max a -> Rep (Max a) unboxingTo :: Rep (Max a) -> Max a
Unboxable a => Unboxable (First a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (First a) :: Type Source # type CoercibleRep (First a) :: Type type IsTrivial (First a) :: Bool Methods unboxingFrom :: First a -> Rep (First a) unboxingTo :: Rep (First a) -> First a
Unboxable a => Unboxable (Last a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Last a) :: Type Source # type CoercibleRep (Last a) :: Type type IsTrivial (Last a) :: Bool Methods unboxingFrom :: Last a -> Rep (Last a) unboxingTo :: Rep (Last a) -> Last a
Unboxable a => Unboxable (WrappedMonoid a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (WrappedMonoid a) :: Type Source # type CoercibleRep (WrappedMonoid a) :: Type type IsTrivial (WrappedMonoid a) :: Bool Methods unboxingFrom :: WrappedMonoid a -> Rep (WrappedMonoid a) unboxingTo :: Rep (WrappedMonoid a) -> WrappedMonoid a
Unboxable a => Unboxable (Identity a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Identity a) :: Type Source # type CoercibleRep (Identity a) :: Type type IsTrivial (Identity a) :: Bool Methods unboxingFrom :: Identity a -> Rep (Identity a) unboxingTo :: Rep (Identity a) -> Identity a
Unboxable a => Unboxable (Dual a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Dual a) :: Type Source # type CoercibleRep (Dual a) :: Type type IsTrivial (Dual a) :: Bool Methods unboxingFrom :: Dual a -> Rep (Dual a) unboxingTo :: Rep (Dual a) -> Dual a
Unboxable a => Unboxable (Sum a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Sum a) :: Type Source # type CoercibleRep (Sum a) :: Type type IsTrivial (Sum a) :: Bool Methods unboxingFrom :: Sum a -> Rep (Sum a) unboxingTo :: Rep (Sum a) -> Sum a
Unboxable a => Unboxable (Product a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Product a) :: Type Source # type CoercibleRep (Product a) :: Type type IsTrivial (Product a) :: Bool Methods unboxingFrom :: Product a -> Rep (Product a) unboxingTo :: Rep (Product a) -> Product a
Unboxable a => Unboxable (Down a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Down a) :: Type Source # type CoercibleRep (Down a) :: Type type IsTrivial (Down a) :: Bool Methods unboxingFrom :: Down a -> Rep (Down a) unboxingTo :: Rep (Down a) -> Down a
(Generic a, Unboxable (Rep' (Rep a)), Unboxable' (Rep a)) => Unboxable (Generics a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Generics a) :: Type Source # type CoercibleRep (Generics a) :: Type type IsTrivial (Generics a) :: Bool Methods unboxingFrom :: Generics a -> Rep (Generics a) unboxingTo :: Rep (Generics a) -> Generics a
(Unboxable a, Unboxable b) => Unboxable (a, b) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (a, b) :: Type Source # type CoercibleRep (a, b) :: Type type IsTrivial (a, b) :: Bool Methods unboxingFrom :: (a, b) -> Rep (a, b) unboxingTo :: Rep (a, b) -> (a, b)
(Unboxable a, Unboxable b, Unboxable c) => Unboxable (a, b, c) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (a, b, c) :: Type Source # type CoercibleRep (a, b, c) :: Type type IsTrivial (a, b, c) :: Bool Methods unboxingFrom :: (a, b, c) -> Rep (a, b, c) unboxingTo :: Rep (a, b, c) -> (a, b, c)
Unboxable a => Unboxable (Const a b) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Const a b) :: Type Source # type CoercibleRep (Const a b) :: Type type IsTrivial (Const a b) :: Bool Methods unboxingFrom :: Const a b -> Rep (Const a b) unboxingTo :: Rep (Const a b) -> Const a b
(Unboxable a, Unboxable b, Unboxable c, Unboxable d) => Unboxable (a, b, c, d) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (a, b, c, d) :: Type Source # type CoercibleRep (a, b, c, d) :: Type type IsTrivial (a, b, c, d) :: Bool Methods unboxingFrom :: (a, b, c, d) -> Rep (a, b, c, d) unboxingTo :: Rep (a, b, c, d) -> (a, b, c, d)
(Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e) => Unboxable (a, b, c, d, e) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (a, b, c, d, e) :: Type Source # type CoercibleRep (a, b, c, d, e) :: Type type IsTrivial (a, b, c, d, e) :: Bool Methods unboxingFrom :: (a, b, c, d, e) -> Rep (a, b, c, d, e) unboxingTo :: Rep (a, b, c, d, e) -> (a, b, c, d, e)
(Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e, Unboxable f) => Unboxable (a, b, c, d, e, f) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (a, b, c, d, e, f) :: Type Source # type CoercibleRep (a, b, c, d, e, f) :: Type type IsTrivial (a, b, c, d, e, f) :: Bool Methods unboxingFrom :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) unboxingTo :: Rep (a, b, c, d, e, f) -> (a, b, c, d, e, f)

newtype Generics a Source #

A newtype wrapper to be used with DerivingVia.

Usage:

data Bar = Bar !Int !Int
  deriving Generic
  deriving Unboxable via Generics Bar

Constructors

Generics a

Instances

(Generic a, Unboxable (Rep' (Rep a)), Unboxable' (Rep a)) => Unboxable (Generics a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal Associated Types type Rep (Generics a) :: Type Source # type CoercibleRep (Generics a) :: Type type IsTrivial (Generics a) :: Bool Methods unboxingFrom :: Generics a -> Rep (Generics a) unboxingTo :: Rep (Generics a) -> Generics a
type Rep (Generics a) Source #
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Generics a)

Accessors

Length information

length :: Unboxable a => Vector a -> Int Source #

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

Indexing

(!) :: Unboxable a => Vector a -> Int -> a Source #

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

head :: Unboxable a => Vector a -> a Source #

last :: Unboxable a => Vector a -> a Source #

unsafeIndex :: Unboxable a => Vector a -> Int -> a Source #

unsafeHead :: Unboxable a => Vector a -> a Source #

unsafeLast :: Unboxable a => Vector a -> a Source #

Monadic indexing

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

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

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

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

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

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

Extracting subvectors (slicing)

slice :: Unboxable a => Int -> Int -> Vector a -> Vector a Source #

init :: Unboxable a => Vector a -> Vector a Source #

tail :: Unboxable a => Vector a -> Vector a Source #

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

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

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

unsafeSlice :: Unboxable a => Int -> Int -> Vector a -> Vector a Source #

unsafeInit :: Unboxable a => Vector a -> Vector a Source #

unsafeTail :: Unboxable a => Vector a -> Vector a Source #

unsafeTake :: Unboxable a => Int -> Vector a -> Vector a Source #

unsafeDrop :: Unboxable a => Int -> Vector a -> Vector a Source #

Construction

Initialisation

empty :: Unboxable a => Vector a Source #

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

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

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

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

Monadic initialisation

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

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

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

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

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

Unfolding

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

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

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

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

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

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

Enumeration

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

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

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

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

Concatenation

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

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

(++) :: Unboxable a => Vector a -> Vector a -> Vector a Source #

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

Restricting memory usage

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

Modifying vectors

Bulk updates

(//) :: Unboxable a => Vector a -> [(Int, a)] -> Vector a Source #

update :: Unboxable a => Vector a -> Vector (Int, a) -> Vector a Source #

update_ :: Unboxable a => Vector a -> Vector Int -> Vector a -> Vector a Source #

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

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

unsafeUpdate_ :: Unboxable a => Vector a -> Vector Int -> Vector a -> Vector a Source #

Accumulations

accum :: Unboxable a => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a Source #

accumulate :: (Unboxable a, Unboxable b) => (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a Source #

accumulate_ :: (Unboxable a, Unboxable b) => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a Source #

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

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

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

Permutations

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

backpermute :: Unboxable a => Vector a -> Vector Int -> Vector a Source #

unsafeBackpermute :: Unboxable a => Vector a -> Vector Int -> Vector a Source #

Safe destructive updates

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

Elementwise operations

Indexing

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

Mapping

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

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

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

Monadic mapping

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

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

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

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

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

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

Zipping

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

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

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

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

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

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

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

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

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

izipWith6 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e, Unboxable f, Unboxable 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 :: (Unboxable a, Unboxable b) => Vector a -> Vector b -> Vector (a, b) Source #

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

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

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

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

Monadic zipping

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

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

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

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

Unzipping

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

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

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

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

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

Working with predicates

Filtering

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

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

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

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

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

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

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

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

Partitioning

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

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

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

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

Searching

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

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

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

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

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

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

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

Folding

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

foldl1 :: Unboxable a => (a -> a -> a) -> Vector a -> a Source #

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

foldl1' :: Unboxable a => (a -> a -> a) -> Vector a -> a Source #

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

foldr1 :: Unboxable a => (a -> a -> a) -> Vector a -> a Source #

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

foldr1' :: Unboxable a => (a -> a -> a) -> Vector a -> a Source #

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

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

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

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

Specialised folds

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

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

and :: Vector Bool -> Bool Source #

or :: Vector Bool -> Bool Source #

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

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

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

maximumBy :: Unboxable a => (a -> a -> Ordering) -> Vector a -> a Source #

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

minimumBy :: Unboxable a => (a -> a -> Ordering) -> Vector a -> a Source #

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

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

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

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

Monadic folds

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

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

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

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

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

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

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

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

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

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

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

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

Prefix sums (scans)

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

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

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

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

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

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

scanl1 :: Unboxable a => (a -> a -> a) -> Vector a -> Vector a Source #

scanl1' :: Unboxable a => (a -> a -> a) -> Vector a -> Vector a Source #

iscanl :: (Unboxable a, Unboxable b) => (Int -> a -> b -> a) -> a -> Vector b -> Vector a Source #

iscanl' :: (Unboxable a, Unboxable b) => (Int -> a -> b -> a) -> a -> Vector b -> Vector a Source #

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

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

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

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

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

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

scanr1 :: Unboxable a => (a -> a -> a) -> Vector a -> Vector a Source #

scanr1' :: Unboxable a => (a -> a -> a) -> Vector a -> Vector a Source #

iscanr :: (Unboxable a, Unboxable b) => (Int -> a -> b -> b) -> b -> Vector a -> Vector b Source #

iscanr' :: (Unboxable a, Unboxable b) => (Int -> a -> b -> b) -> b -> Vector a -> Vector b Source #

Conversions

Lists

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

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

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

Other vector types

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

O(n) Convert different vector types

toUnboxedVector :: (Unboxable a, Rep a ~ a, IsTrivial a ~ True) => Vector a -> Vector a Source #

fromUnboxedVector :: (Unboxable a, Rep a ~ a, IsTrivial a ~ True) => Vector a -> Vector a Source #

coerceVector :: (Coercible a b, Unboxable a, Unboxable b, CoercibleRep a ~ CoercibleRep b, Rep a ~ Rep b) => Vector a -> Vector b Source #

liftCoercion :: (Unboxable a, Unboxable b, CoercibleRep a ~ CoercibleRep b, Rep a ~ Rep b) => Coercion a b -> Coercion (Vector a) (Vector b) Source #

vectorCoercion :: (Coercible a b, Unboxable a, Unboxable b, CoercibleRep a ~ CoercibleRep b, Rep a ~ Rep b) => Coercion (Vector a) (Vector b) Source #

Mutable vectors

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

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

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

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

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

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