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
newtype Enum a = Enum a
newtype EnumRep rep a = EnumRep 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
coercionWithUnboxedVector :: (Unboxable a, Rep a ~ a, IsTrivial a ~ 'True) => Coercion (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

Instances details

Unboxable a => Vector Vector a Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Methods

basicUnsafeFreeze :: Mutable Vector s a -> ST s (Vector a)

basicUnsafeThaw :: Vector a -> ST s (Mutable Vector s a)

basicLength :: Vector a -> Int

basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a

basicUnsafeIndexM :: Vector a -> Int -> Box a

basicUnsafeCopy :: Mutable Vector s a -> Vector a -> ST s ()

elemseq :: Vector a -> a -> b -> b

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 #

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 => IsList (Vector a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Item (Vector a)
Instance details Defined in Data.Vector.Unboxing.Internal type Item (Vector a) = a

Methods

fromList :: [Item (Vector a)] -> Vector a #

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

toList :: Vector a -> [Item (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 #

NFData (Vector a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Methods

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

Unboxable a => GrowingAppend (Vector a) Source #

Instance details

Defined in Data.Vector.Unboxing.Instances

Unboxable a => MonoFoldable (Vector a) Source #

Instance details

Defined in Data.Vector.Unboxing.Instances

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 => MonoFunctor (Vector a) Source #

Instance details

Defined in Data.Vector.Unboxing.Instances

Methods

omap :: (Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a #

Unboxable a => MonoPointed (Vector a) Source #

Instance details

Defined in Data.Vector.Unboxing.Instances

Methods

opoint :: Element (Vector a) -> Vector a #

Unboxable a => MonoTraversable (Vector a) Source #

Instance details

Defined in Data.Vector.Unboxing.Instances

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 => IsSequence (Vector a) Source #

Instance details

Defined in Data.Vector.Unboxing.Instances

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

tails :: Vector a -> [Vector a] #

inits :: Vector a -> [Vector a] #

initTails :: Vector a -> [(Vector a, Vector a)] #

Unboxable a => SemiSequence (Vector a) Source #

Instance details

Defined in Data.Vector.Unboxing.Instances

Associated Types

type Index (Vector a)
Instance details Defined in Data.Vector.Unboxing.Instances type Index (Vector a) = Int

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 #

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 Element (Vector a) Source #

Instance details

Defined in Data.Vector.Unboxing.Instances

type Element (Vector a) = a

type Index (Vector a) Source #

Instance details

Defined in Data.Vector.Unboxing.Instances

type Index (Vector a) = Int

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

Instances details

Unboxable All Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep All
Instance details Defined in Data.Vector.Unboxing.Internal type Rep 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
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Any = Bool

Methods

unboxingFrom :: Any -> Rep Any

unboxingTo :: Rep Any -> Any

Unboxable Int16 Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep Int16
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Int16 = Int16

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
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Int32 = Int32

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
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Int64 = Int64

Methods

unboxingFrom :: Int64 -> Rep Int64

unboxingTo :: Rep Int64 -> Int64

Unboxable Int8 Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep Int8
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Int8 = Int8

Methods

unboxingFrom :: Int8 -> Rep Int8

unboxingTo :: Rep Int8 -> Int8

Unboxable Word16 Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep Word16
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Word16 = Word16

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
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Word32 = Word32

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
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Word64 = Word64

Methods

unboxingFrom :: Word64 -> Rep Word64

unboxingTo :: Rep Word64 -> Word64

Unboxable Word8 Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep Word8
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Word8 = Word8

Methods

unboxingFrom :: Word8 -> Rep Word8

unboxingTo :: Rep Word8 -> Word8

Unboxable Ordering Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep Ordering
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Ordering = Int8

Methods

unboxingFrom :: Ordering -> Rep Ordering

unboxingTo :: Rep Ordering -> Ordering

Unboxable () Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep ()
Instance details Defined in Data.Vector.Unboxing.Internal type Rep () = ()

Methods

unboxingFrom :: () -> Rep ()

unboxingTo :: Rep () -> ()

Unboxable Bool Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep Bool
Instance details Defined in Data.Vector.Unboxing.Internal type Rep 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
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Char = Char

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
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Double = Double

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
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Float = Float

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
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Int = Int

Methods

unboxingFrom :: Int -> Rep Int

unboxingTo :: Rep Int -> Int

Unboxable Word Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep Word
Instance details Defined in Data.Vector.Unboxing.Internal type Rep Word = Word

Methods

unboxingFrom :: Word -> Rep Word

unboxingTo :: Rep Word -> Word

Unboxable a => Unboxable (Complex a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Complex a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Complex a) = Complex (Rep a)

Methods

unboxingFrom :: Complex a -> Rep (Complex a)

unboxingTo :: Rep (Complex a) -> Complex a

Unboxable a => Unboxable (Identity a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Identity a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Identity a) = Rep a

Methods

unboxingFrom :: Identity a -> Rep (Identity a)

unboxingTo :: Rep (Identity a) -> Identity a

Unboxable a => Unboxable (Down a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Down a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Down a) = Rep a

Methods

unboxingFrom :: Down a -> Rep (Down a)

unboxingTo :: Rep (Down a) -> Down a

Unboxable a => Unboxable (First a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (First a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (First a) = Rep a

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)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Last a) = Rep a

Methods

unboxingFrom :: Last a -> Rep (Last a)

unboxingTo :: Rep (Last a) -> Last a

Unboxable a => Unboxable (Max a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Max a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Max a) = Rep a

Methods

unboxingFrom :: Max a -> Rep (Max a)

unboxingTo :: Rep (Max a) -> Max a

Unboxable a => Unboxable (Min a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Min a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Min a) = Rep a

Methods

unboxingFrom :: Min a -> Rep (Min a)

unboxingTo :: Rep (Min a) -> Min a

Unboxable a => Unboxable (WrappedMonoid a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (WrappedMonoid a) = Rep a

Methods

unboxingFrom :: WrappedMonoid a -> Rep (WrappedMonoid a)

unboxingTo :: Rep (WrappedMonoid a) -> WrappedMonoid a

Unboxable a => Unboxable (Dual a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Dual a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Dual a) = Rep a

Methods

unboxingFrom :: Dual a -> Rep (Dual a)

unboxingTo :: Rep (Dual a) -> Dual a

Unboxable a => Unboxable (Product a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Product a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Product a) = Rep a

Methods

unboxingFrom :: Product a -> Rep (Product a)

unboxingTo :: Rep (Product a) -> Product a

Unboxable a => Unboxable (Sum a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Sum a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Sum a) = Rep a

Methods

unboxingFrom :: Sum a -> Rep (Sum a)

unboxingTo :: Rep (Sum a) -> Sum a

Enum a => Unboxable (Enum a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Enum a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Enum a) = Int

Methods

unboxingFrom :: Enum a -> Rep (Enum a)

unboxingTo :: Rep (Enum a) -> Enum a

(Generic a, Unbox (Rep' (Rep a)), Unboxable' (Rep a)) => Unboxable (Generics a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Generics a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Generics a)

Methods

unboxingFrom :: Generics a -> Rep (Generics a)

unboxingTo :: Rep (Generics a) -> Generics a

(Unboxable a, Unboxable b) => Unboxable (Arg a b) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Arg a b)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Arg a b) = (Rep a, Rep b)

Methods

unboxingFrom :: Arg a b -> Rep (Arg a b)

unboxingTo :: Rep (Arg a b) -> Arg a b

(Enum a, Integral rep, Unbox rep) => Unboxable (EnumRep rep a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (EnumRep rep a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (EnumRep rep a) = rep

Methods

unboxingFrom :: EnumRep rep a -> Rep (EnumRep rep a)

unboxingTo :: Rep (EnumRep rep a) -> EnumRep rep a

(Unboxable a, Unboxable b) => Unboxable (a, b) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (a, b)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (a, b) = (Rep a, Rep b)

Methods

unboxingFrom :: (a, b) -> Rep (a, b)

unboxingTo :: Rep (a, b) -> (a, b)

Unboxable a => Unboxable (Const a b) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Const a b)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Const a b) = Rep a

Methods

unboxingFrom :: Const a b -> Rep (Const a b)

unboxingTo :: Rep (Const a b) -> Const a b

Unboxable (f a) => Unboxable (Alt f a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Alt f a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Alt f a) = Rep (f a)

Methods

unboxingFrom :: Alt f a -> Rep (Alt f a)

unboxingTo :: Rep (Alt f a) -> Alt f a

(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)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (a, b, c) = (Rep a, Rep b, Rep c)

Methods

unboxingFrom :: (a, b, c) -> Rep (a, b, c)

unboxingTo :: Rep (a, b, c) -> (a, b, c)

(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)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (a, b, c, d) = (Rep a, Rep b, Rep c, Rep d)

Methods

unboxingFrom :: (a, b, c, d) -> Rep (a, b, c, d)

unboxingTo :: Rep (a, b, c, d) -> (a, b, c, d)

Unboxable (f (g a)) => Unboxable (Compose f g a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Compose f g a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Compose f g a) = Rep (f (g a))

Methods

unboxingFrom :: Compose f g a -> Rep (Compose f g a)

unboxingTo :: Rep (Compose f g a) -> Compose f g a

(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)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (a, b, c, d, e) = (Rep a, Rep b, Rep c, Rep d, Rep e)

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)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (a, b, c, d, e, f) = (Rep a, Rep b, Rep c, Rep d, Rep e, Rep f)

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

Instances details

(Generic a, Unbox (Rep' (Rep a)), Unboxable' (Rep a)) => Unboxable (Generics a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Generics a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Generics a)

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)

newtype Enum a Source #

A newtype wrapper to be used with DerivingVia. The value will be stored as Int, via fromEnum/toEnum.

Usage:

data Direction = North | South | East | West
  deriving Enum
  deriving Data.Vector.Unboxing.Unboxable via Data.Vector.Unboxing.Enum Bar

Constructors

Enum a

Instances

Instances details

Enum a => Unboxable (Enum a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (Enum a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (Enum a) = Int

Methods

unboxingFrom :: Enum a -> Rep (Enum a)

unboxingTo :: Rep (Enum a) -> Enum a

type Rep (Enum a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

type Rep (Enum a) = Int

newtype EnumRep rep a Source #

A newtype wrapper to be used with DerivingVia.

Usage:

data Direction = North | South | East | West
  deriving Enum
  deriving Data.Vector.Unboxing.Unboxable via Data.Vector.Unboxing.EnumRep Int8 Bar

Constructors

EnumRep a

Instances

Instances details

(Enum a, Integral rep, Unbox rep) => Unboxable (EnumRep rep a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

Associated Types

type Rep (EnumRep rep a)
Instance details Defined in Data.Vector.Unboxing.Internal type Rep (EnumRep rep a) = rep

Methods

unboxingFrom :: EnumRep rep a -> Rep (EnumRep rep a)

unboxingTo :: Rep (EnumRep rep a) -> EnumRep rep a

type Rep (EnumRep rep a) Source #

Instance details

Defined in Data.Vector.Unboxing.Internal

type Rep (EnumRep rep a) = rep

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 #

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 #

coercionWithUnboxedVector :: (Unboxable a, Rep a ~ a, IsTrivial a ~ 'True) => Coercion (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 #