rebase-1.21.2: A more progressive alternative to the "base" package
Safe HaskellNone
LanguageHaskell2010

Rebase.Data.Vector.Generic

Documentation

eq :: (Vector v a, Eq a) => v a -> v a -> Bool #

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

(++) :: Vector v a => v a -> v a -> v a #

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

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

(!) :: (HasCallStack, Vector v a) => v a -> Int -> a #

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

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

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

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

freeze :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m (v a) #

unsafeFreeze :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m (v a) #

thaw :: (PrimMonad m, Vector v a) => v a -> m (Mutable v (PrimState m) a) #

unsafeThaw :: (PrimMonad m, Vector v a) => v a -> m (Mutable v (PrimState m) a) #

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

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

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

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

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

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

showsPrec :: (Vector v a, Show a) => Int -> v a -> ShowS #

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

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

group :: (Vector v a, Eq a) => v a -> [v a] #

groupBy :: Vector v a => (a -> a -> Bool) -> v a -> [v a] #

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

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

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

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

sequence :: (Monad m, Vector v a, Vector v (m a)) => v (m a) -> m (v a) #

new :: Vector v a => New v a -> v a #

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

sequence_ :: (Monad m, Vector v (m a)) => v (m a) -> m () #

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

foldMap :: (Monoid m, Vector v a) => (a -> m) -> v a -> m #

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

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

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

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

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

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

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

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

empty :: Vector v a => v a #

uncons :: Vector v a => v a -> Maybe (a, v a) #

unsnoc :: Vector v a => v a -> Maybe (v a, a) #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

and :: Vector v Bool => v Bool -> Bool #

or :: Vector v Bool => v Bool -> Bool #

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

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

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

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

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

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

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

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

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

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

readPrec :: (Vector v a, Read a) => ReadPrec (v a) #

foldMap' :: (Monoid m, Vector v a) => (a -> m) -> v a -> m #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

gfoldl :: (Vector v a, Data a) => (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> v a -> c (v a) #

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

liftShowsPrec :: Vector v a => (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> v a -> ShowS #

liftReadsPrec :: Vector v a => (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (v a) #

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

copy :: (HasCallStack, PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m () #

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

create :: Vector v a => (forall s. ST s (Mutable v s a)) -> v a #

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

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

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

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

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

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

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

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

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

findIndexR :: Vector v a => (a -> Bool) -> v a -> Maybe Int #

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

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

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

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

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

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

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

iforM :: (Monad m, Vector v a, Vector v b) => v a -> (Int -> a -> m b) -> m (v b) #

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

iforM_ :: (Monad m, Vector v a) => v a -> (Int -> a -> m b) -> m () #

modify :: Vector v a => (forall s. Mutable v s a -> ST s ()) -> v a -> v a #

unstream :: Vector v a => Bundle v a -> v a #

stream :: Vector v a => v a -> Bundle v a #

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

clone :: Vector v a => v a -> New v a #

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

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

slice :: (HasCallStack, Vector v a) => Int -> Int -> v a -> v a #

eqBy :: (Vector v a, Vector v b) => (a -> b -> Bool) -> v a -> v b -> Bool #

cmpBy :: (Vector v a, Vector v b) => (a -> b -> Ordering) -> v a -> v b -> Ordering #

mapMaybeM :: (Monad m, Vector v a, Vector v b) => (a -> m (Maybe b)) -> v a -> m (v b) #

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

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

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

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

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

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

unfoldrExactN :: Vector v a => Int -> (b -> (a, b)) -> b -> v a #

unfoldrExactNM :: (Monad m, Vector v a) => Int -> (b -> m (a, b)) -> b -> m (v a) #

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

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

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

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

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

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

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

class MVector (Mutable v) a => Vector (v :: Type -> Type) a where #

Minimal complete definition

basicUnsafeFreeze, basicUnsafeThaw, basicLength, basicUnsafeSlice, basicUnsafeIndexM

Methods

basicUnsafeFreeze :: Mutable v s a -> ST s (v a) #

basicUnsafeThaw :: v a -> ST s (Mutable v s a) #

basicLength :: v a -> Int #

basicUnsafeSlice :: Int -> Int -> v a -> v a #

basicUnsafeIndexM :: v a -> Int -> Box a #

basicUnsafeCopy :: Mutable v s a -> v a -> ST s () #

elemseq :: v a -> a -> b -> b #

Instances

Instances details
Vector Vector a 
Instance details

Defined in Data.Vector

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 #

Prim a => Vector Vector a 
Instance details

Defined in Data.Vector.Primitive

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 #

Storable a => Vector Vector a 
Instance details

Defined in Data.Vector.Storable

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 #

Vector Vector a 
Instance details

Defined in Data.Vector.Strict

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 #

Vector Vector All 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s All -> ST s (Vector All) #

basicUnsafeThaw :: Vector All -> ST s (Mutable Vector s All) #

basicLength :: Vector All -> Int #

basicUnsafeSlice :: Int -> Int -> Vector All -> Vector All #

basicUnsafeIndexM :: Vector All -> Int -> Box All #

basicUnsafeCopy :: Mutable Vector s All -> Vector All -> ST s () #

elemseq :: Vector All -> All -> b -> b #

Vector Vector Any 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Any -> ST s (Vector Any) #

basicUnsafeThaw :: Vector Any -> ST s (Mutable Vector s Any) #

basicLength :: Vector Any -> Int #

basicUnsafeSlice :: Int -> Int -> Vector Any -> Vector Any #

basicUnsafeIndexM :: Vector Any -> Int -> Box Any #

basicUnsafeCopy :: Mutable Vector s Any -> Vector Any -> ST s () #

elemseq :: Vector Any -> Any -> b -> b #

Vector Vector Int16 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Int16 -> ST s (Vector Int16) #

basicUnsafeThaw :: Vector Int16 -> ST s (Mutable Vector s Int16) #

basicLength :: Vector Int16 -> Int #

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

basicUnsafeIndexM :: Vector Int16 -> Int -> Box Int16 #

basicUnsafeCopy :: Mutable Vector s Int16 -> Vector Int16 -> ST s () #

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

Vector Vector Int32 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Int32 -> ST s (Vector Int32) #

basicUnsafeThaw :: Vector Int32 -> ST s (Mutable Vector s Int32) #

basicLength :: Vector Int32 -> Int #

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

basicUnsafeIndexM :: Vector Int32 -> Int -> Box Int32 #

basicUnsafeCopy :: Mutable Vector s Int32 -> Vector Int32 -> ST s () #

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

Vector Vector Int64 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Int64 -> ST s (Vector Int64) #

basicUnsafeThaw :: Vector Int64 -> ST s (Mutable Vector s Int64) #

basicLength :: Vector Int64 -> Int #

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

basicUnsafeIndexM :: Vector Int64 -> Int -> Box Int64 #

basicUnsafeCopy :: Mutable Vector s Int64 -> Vector Int64 -> ST s () #

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

Vector Vector Int8 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Int8 -> ST s (Vector Int8) #

basicUnsafeThaw :: Vector Int8 -> ST s (Mutable Vector s Int8) #

basicLength :: Vector Int8 -> Int #

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

basicUnsafeIndexM :: Vector Int8 -> Int -> Box Int8 #

basicUnsafeCopy :: Mutable Vector s Int8 -> Vector Int8 -> ST s () #

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

Vector Vector Word16 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Word16 -> ST s (Vector Word16) #

basicUnsafeThaw :: Vector Word16 -> ST s (Mutable Vector s Word16) #

basicLength :: Vector Word16 -> Int #

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

basicUnsafeIndexM :: Vector Word16 -> Int -> Box Word16 #

basicUnsafeCopy :: Mutable Vector s Word16 -> Vector Word16 -> ST s () #

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

Vector Vector Word32 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Word32 -> ST s (Vector Word32) #

basicUnsafeThaw :: Vector Word32 -> ST s (Mutable Vector s Word32) #

basicLength :: Vector Word32 -> Int #

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

basicUnsafeIndexM :: Vector Word32 -> Int -> Box Word32 #

basicUnsafeCopy :: Mutable Vector s Word32 -> Vector Word32 -> ST s () #

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

Vector Vector Word64 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Word64 -> ST s (Vector Word64) #

basicUnsafeThaw :: Vector Word64 -> ST s (Mutable Vector s Word64) #

basicLength :: Vector Word64 -> Int #

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

basicUnsafeIndexM :: Vector Word64 -> Int -> Box Word64 #

basicUnsafeCopy :: Mutable Vector s Word64 -> Vector Word64 -> ST s () #

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

Vector Vector Word8 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Word8 -> ST s (Vector Word8) #

basicUnsafeThaw :: Vector Word8 -> ST s (Mutable Vector s Word8) #

basicLength :: Vector Word8 -> Int #

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

basicUnsafeIndexM :: Vector Word8 -> Int -> Box Word8 #

basicUnsafeCopy :: Mutable Vector s Word8 -> Vector Word8 -> ST s () #

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

Vector Vector () 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector () -> Int #

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

basicUnsafeIndexM :: Vector () -> Int -> Box () #

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

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

Vector Vector Bool 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Bool -> ST s (Vector Bool) #

basicUnsafeThaw :: Vector Bool -> ST s (Mutable Vector s Bool) #

basicLength :: Vector Bool -> Int #

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

basicUnsafeIndexM :: Vector Bool -> Int -> Box Bool #

basicUnsafeCopy :: Mutable Vector s Bool -> Vector Bool -> ST s () #

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

Vector Vector Char 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Char -> ST s (Vector Char) #

basicUnsafeThaw :: Vector Char -> ST s (Mutable Vector s Char) #

basicLength :: Vector Char -> Int #

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

basicUnsafeIndexM :: Vector Char -> Int -> Box Char #

basicUnsafeCopy :: Mutable Vector s Char -> Vector Char -> ST s () #

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

Vector Vector Double 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Double -> ST s (Vector Double) #

basicUnsafeThaw :: Vector Double -> ST s (Mutable Vector s Double) #

basicLength :: Vector Double -> Int #

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

basicUnsafeIndexM :: Vector Double -> Int -> Box Double #

basicUnsafeCopy :: Mutable Vector s Double -> Vector Double -> ST s () #

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

Vector Vector Float 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Float -> ST s (Vector Float) #

basicUnsafeThaw :: Vector Float -> ST s (Mutable Vector s Float) #

basicLength :: Vector Float -> Int #

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

basicUnsafeIndexM :: Vector Float -> Int -> Box Float #

basicUnsafeCopy :: Mutable Vector s Float -> Vector Float -> ST s () #

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

Vector Vector Int 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Int -> ST s (Vector Int) #

basicUnsafeThaw :: Vector Int -> ST s (Mutable Vector s Int) #

basicLength :: Vector Int -> Int #

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

basicUnsafeIndexM :: Vector Int -> Int -> Box Int #

basicUnsafeCopy :: Mutable Vector s Int -> Vector Int -> ST s () #

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

Vector Vector Word 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s Word -> ST s (Vector Word) #

basicUnsafeThaw :: Vector Word -> ST s (Mutable Vector s Word) #

basicLength :: Vector Word -> Int #

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

basicUnsafeIndexM :: Vector Word -> Int -> Box Word #

basicUnsafeCopy :: Mutable Vector s Word -> Vector Word -> ST s () #

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

Unbox a => Vector Vector (Complex a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

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

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

basicUnsafeIndexM :: Vector (Complex a) -> Int -> Box (Complex a) #

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

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

Unbox a => Vector Vector (Identity a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (Identity a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Identity a) -> Vector (Identity a) #

basicUnsafeIndexM :: Vector (Identity a) -> Int -> Box (Identity a) #

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

elemseq :: Vector (Identity a) -> Identity a -> b -> b #

Unbox a => Vector Vector (Down a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (Down a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Down a) -> Vector (Down a) #

basicUnsafeIndexM :: Vector (Down a) -> Int -> Box (Down a) #

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

elemseq :: Vector (Down a) -> Down a -> b -> b #

Unbox a => Vector Vector (First a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (First a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (First a) -> Vector (First a) #

basicUnsafeIndexM :: Vector (First a) -> Int -> Box (First a) #

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

elemseq :: Vector (First a) -> First a -> b -> b #

Unbox a => Vector Vector (Last a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (Last a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Last a) -> Vector (Last a) #

basicUnsafeIndexM :: Vector (Last a) -> Int -> Box (Last a) #

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

elemseq :: Vector (Last a) -> Last a -> b -> b #

Unbox a => Vector Vector (Max a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (Max a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Max a) -> Vector (Max a) #

basicUnsafeIndexM :: Vector (Max a) -> Int -> Box (Max a) #

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

elemseq :: Vector (Max a) -> Max a -> b -> b #

Unbox a => Vector Vector (Min a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (Min a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Min a) -> Vector (Min a) #

basicUnsafeIndexM :: Vector (Min a) -> Int -> Box (Min a) #

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

elemseq :: Vector (Min a) -> Min a -> b -> b #

Unbox a => Vector Vector (WrappedMonoid a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (WrappedMonoid a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (WrappedMonoid a) -> Vector (WrappedMonoid a) #

basicUnsafeIndexM :: Vector (WrappedMonoid a) -> Int -> Box (WrappedMonoid a) #

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

elemseq :: Vector (WrappedMonoid a) -> WrappedMonoid a -> b -> b #

Unbox a => Vector Vector (Dual a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (Dual a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Dual a) -> Vector (Dual a) #

basicUnsafeIndexM :: Vector (Dual a) -> Int -> Box (Dual a) #

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

elemseq :: Vector (Dual a) -> Dual a -> b -> b #

Unbox a => Vector Vector (Product a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (Product a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Product a) -> Vector (Product a) #

basicUnsafeIndexM :: Vector (Product a) -> Int -> Box (Product a) #

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

elemseq :: Vector (Product a) -> Product a -> b -> b #

Unbox a => Vector Vector (Sum a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (Sum a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Sum a) -> Vector (Sum a) #

basicUnsafeIndexM :: Vector (Sum a) -> Int -> Box (Sum a) #

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

elemseq :: Vector (Sum a) -> Sum a -> b -> b #

Vector Vector (DoNotUnboxLazy a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (DoNotUnboxLazy a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxLazy a) -> Vector (DoNotUnboxLazy a) #

basicUnsafeIndexM :: Vector (DoNotUnboxLazy a) -> Int -> Box (DoNotUnboxLazy a) #

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

elemseq :: Vector (DoNotUnboxLazy a) -> DoNotUnboxLazy a -> b -> b #

NFData a => Vector Vector (DoNotUnboxNormalForm a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (DoNotUnboxNormalForm a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxNormalForm a) -> Vector (DoNotUnboxNormalForm a) #

basicUnsafeIndexM :: Vector (DoNotUnboxNormalForm a) -> Int -> Box (DoNotUnboxNormalForm a) #

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

elemseq :: Vector (DoNotUnboxNormalForm a) -> DoNotUnboxNormalForm a -> b -> b #

Vector Vector (DoNotUnboxStrict a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (DoNotUnboxStrict a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (DoNotUnboxStrict a) -> Vector (DoNotUnboxStrict a) #

basicUnsafeIndexM :: Vector (DoNotUnboxStrict a) -> Int -> Box (DoNotUnboxStrict a) #

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

elemseq :: Vector (DoNotUnboxStrict a) -> DoNotUnboxStrict a -> b -> b #

Prim a => Vector Vector (UnboxViaPrim a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

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

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

basicLength :: Vector (UnboxViaPrim a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (UnboxViaPrim a) -> Vector (UnboxViaPrim a) #

basicUnsafeIndexM :: Vector (UnboxViaPrim a) -> Int -> Box (UnboxViaPrim a) #

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

elemseq :: Vector (UnboxViaPrim a) -> UnboxViaPrim a -> b -> b #

(Unbox a, Unbox b) => Vector Vector (Arg a b) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Arg a b) -> ST s (Vector (Arg a b)) #

basicUnsafeThaw :: Vector (Arg a b) -> ST s (Mutable Vector s (Arg a b)) #

basicLength :: Vector (Arg a b) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Arg a b) -> Vector (Arg a b) #

basicUnsafeIndexM :: Vector (Arg a b) -> Int -> Box (Arg a b) #

basicUnsafeCopy :: Mutable Vector s (Arg a b) -> Vector (Arg a b) -> ST s () #

elemseq :: Vector (Arg a b) -> Arg a b -> b0 -> b0 #

(IsoUnbox a b, Unbox b) => Vector Vector (As a b) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (As a b) -> ST s (Vector (As a b)) #

basicUnsafeThaw :: Vector (As a b) -> ST s (Mutable Vector s (As a b)) #

basicLength :: Vector (As a b) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (As a b) -> Vector (As a b) #

basicUnsafeIndexM :: Vector (As a b) -> Int -> Box (As a b) #

basicUnsafeCopy :: Mutable Vector s (As a b) -> Vector (As a b) -> ST s () #

elemseq :: Vector (As a b) -> As a b -> b0 -> b0 #

(Unbox a, Unbox b) => Vector Vector (a, b) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (a, b) -> ST s (Vector (a, b)) #

basicUnsafeThaw :: Vector (a, b) -> ST s (Mutable Vector s (a, b)) #

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

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

basicUnsafeIndexM :: Vector (a, b) -> Int -> Box (a, b) #

basicUnsafeCopy :: Mutable Vector s (a, b) -> Vector (a, b) -> ST s () #

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

Unbox a => Vector Vector (Const a b) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Const a b) -> ST s (Vector (Const a b)) #

basicUnsafeThaw :: Vector (Const a b) -> ST s (Mutable Vector s (Const a b)) #

basicLength :: Vector (Const a b) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b) #

basicUnsafeIndexM :: Vector (Const a b) -> Int -> Box (Const a b) #

basicUnsafeCopy :: Mutable Vector s (Const a b) -> Vector (Const a b) -> ST s () #

elemseq :: Vector (Const a b) -> Const a b -> b0 -> b0 #

Unbox (f a) => Vector Vector (Alt f a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Alt f a) -> ST s (Vector (Alt f a)) #

basicUnsafeThaw :: Vector (Alt f a) -> ST s (Mutable Vector s (Alt f a)) #

basicLength :: Vector (Alt f a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Alt f a) -> Vector (Alt f a) #

basicUnsafeIndexM :: Vector (Alt f a) -> Int -> Box (Alt f a) #

basicUnsafeCopy :: Mutable Vector s (Alt f a) -> Vector (Alt f a) -> ST s () #

elemseq :: Vector (Alt f a) -> Alt f a -> b -> b #

(Unbox a, Unbox b, Unbox c) => Vector Vector (a, b, c) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (a, b, c) -> ST s (Vector (a, b, c)) #

basicUnsafeThaw :: Vector (a, b, c) -> ST s (Mutable Vector s (a, b, c)) #

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

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

basicUnsafeIndexM :: Vector (a, b, c) -> Int -> Box (a, b, c) #

basicUnsafeCopy :: Mutable Vector s (a, b, c) -> Vector (a, b, c) -> ST s () #

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

(Unbox a, Unbox b, Unbox c, Unbox d) => Vector Vector (a, b, c, d) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (a, b, c, d) -> ST s (Vector (a, b, c, d)) #

basicUnsafeThaw :: Vector (a, b, c, d) -> ST s (Mutable Vector s (a, b, c, d)) #

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

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

basicUnsafeIndexM :: Vector (a, b, c, d) -> Int -> Box (a, b, c, d) #

basicUnsafeCopy :: Mutable Vector s (a, b, c, d) -> Vector (a, b, c, d) -> ST s () #

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

Unbox (f (g a)) => Vector Vector (Compose f g a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (Compose f g a) -> ST s (Vector (Compose f g a)) #

basicUnsafeThaw :: Vector (Compose f g a) -> ST s (Mutable Vector s (Compose f g a)) #

basicLength :: Vector (Compose f g a) -> Int #

basicUnsafeSlice :: Int -> Int -> Vector (Compose f g a) -> Vector (Compose f g a) #

basicUnsafeIndexM :: Vector (Compose f g a) -> Int -> Box (Compose f g a) #

basicUnsafeCopy :: Mutable Vector s (Compose f g a) -> Vector (Compose f g a) -> ST s () #

elemseq :: Vector (Compose f g a) -> Compose f g a -> b -> b #

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

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (a, b, c, d, e) -> ST s (Vector (a, b, c, d, e)) #

basicUnsafeThaw :: Vector (a, b, c, d, e) -> ST s (Mutable Vector s (a, b, c, d, e)) #

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

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

basicUnsafeIndexM :: Vector (a, b, c, d, e) -> Int -> Box (a, b, c, d, e) #

basicUnsafeCopy :: Mutable Vector s (a, b, c, d, e) -> Vector (a, b, c, d, e) -> ST s () #

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

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector Vector (a, b, c, d, e, f) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: Mutable Vector s (a, b, c, d, e, f) -> ST s (Vector (a, b, c, d, e, f)) #

basicUnsafeThaw :: Vector (a, b, c, d, e, f) -> ST s (Mutable Vector s (a, b, c, d, e, f)) #

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

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

basicUnsafeIndexM :: Vector (a, b, c, d, e, f) -> Int -> Box (a, b, c, d, e, f) #

basicUnsafeCopy :: Mutable Vector s (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> ST s () #

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

type family Mutable (v :: Type -> Type) = (mv :: Type -> Type -> Type) | mv -> v #

Instances

Instances details
type Mutable Array 
Instance details

Defined in Data.Vector.Generic.Base

type Mutable Array = MutableArray
type Mutable PrimArray 
Instance details

Defined in Data.Vector.Generic.Base

type Mutable PrimArray = MutablePrimArray
type Mutable SmallArray 
Instance details

Defined in Data.Vector.Generic.Base

type Mutable SmallArray = SmallMutableArray
type Mutable Vector 
Instance details

Defined in Data.Vector

type Mutable Vector = MVector
type Mutable Vector 
Instance details

Defined in Data.Vector.Primitive

type Mutable Vector = MVector
type Mutable Vector 
Instance details

Defined in Data.Vector.Storable

type Mutable Vector = MVector
type Mutable Vector 
Instance details

Defined in Data.Vector.Strict

type Mutable Vector = MVector
type Mutable Vector 
Instance details

Defined in Data.Vector.Unboxed.Base

type Mutable Vector = MVector

cmp :: (Vector v a, Ord a) => v a -> v a -> Ordering #

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

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

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

backpermute :: (HasCallStack, Vector v a, Vector v Int) => v a -> v Int -> v a #

breakR :: Vector v a => (a -> Bool) -> v a -> (v a, v a) #

concatNE :: Vector v a => NonEmpty (v a) -> v a #

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

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

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

dataCast :: (Vector v a, Data a, Typeable v, Typeable t) => (forall d. Data d => c (t d)) -> Maybe (c (v a)) #

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

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

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

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

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

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

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

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

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

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

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

imapMaybeM :: (Monad m, Vector v a, Vector v b) => (Int -> a -> m (Maybe b)) -> v a -> m (v b) #

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

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

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

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

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

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

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

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

izipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g) => (Int -> a -> b -> c -> d -> e -> f -> g) -> v a -> v b -> v c -> v d -> v e -> v f -> v g #

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

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

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

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

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

maximumOn :: (Ord b, Vector v a) => (a -> b) -> v a -> a #

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

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

minimumOn :: (Ord b, Vector v a) => (a -> b) -> v a -> a #

mkVecConstr :: String -> Constr #

mkVecType :: String -> DataType #

partitionWith :: (Vector v a, Vector v b, Vector v c) => (a -> Either b c) -> v a -> (v b, v c) #

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

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

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

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

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

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

spanR :: Vector v a => (a -> Bool) -> v a -> (v a, v a) #

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

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

unsafeBackpermute :: (Vector v a, Vector v Int) => v a -> v Int -> v a #

unsafeCopy :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m () #

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

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

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

unsafeSlice :: Vector v a => Int -> Int -> v a -> v a #

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

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

unsafeUpdate_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a #

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

update_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a #

unstreamM :: forall m v a (u :: Type -> Type). (Monad m, Vector v a) => MBundle m u a -> m (v a) #

streamR :: forall v a (u :: Type -> Type). Vector v a => v a -> Bundle u a #

unstreamR :: Vector v a => Bundle v a -> v a #

mkType :: String -> DataType #