sdp4vector-0.2: SDP wrapper for Vector
Copyright(c) Andrey Mulik 2019
LicenseBSD-style
Maintainerwork.a.mulik@gmail.com
Portabilityportable
Safe HaskellTrustworthy
LanguageHaskell2010

SDP.Vector

Description

SDP.Vector provides Vector - immutable lazy boxed vector.

Synopsis

Exports

module SDP.Sort

module SDP.Scan

Vector

data Vector a #

Boxed vectors, supporting efficient slicing.

Instances

Instances details
Monad Vector 
Instance details

Defined in Data.Vector

Methods

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

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

return :: a -> Vector a #

Functor Vector 
Instance details

Defined in Data.Vector

Methods

fmap :: (a -> b) -> Vector a -> Vector b #

(<$) :: a -> Vector b -> Vector a #

MonadFix Vector

Instance has same semantics as one for lists

Since: vector-0.12.2.0

Instance details

Defined in Data.Vector

Methods

mfix :: (a -> Vector a) -> Vector a #

MonadFail Vector

Since: vector-0.12.1.0

Instance details

Defined in Data.Vector

Methods

fail :: String -> Vector a #

Applicative Vector 
Instance details

Defined in Data.Vector

Methods

pure :: a -> Vector a #

(<*>) :: Vector (a -> b) -> Vector a -> Vector b #

liftA2 :: (a -> b -> c) -> Vector a -> Vector b -> Vector c #

(*>) :: Vector a -> Vector b -> Vector b #

(<*) :: Vector a -> Vector b -> Vector a #

Foldable Vector 
Instance details

Defined in Data.Vector

Methods

fold :: Monoid m => Vector m -> m #

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

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

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

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

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

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

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

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

toList :: Vector a -> [a] #

null :: Vector a -> Bool #

length :: Vector a -> Int #

elem :: Eq a => a -> Vector a -> Bool #

maximum :: Ord a => Vector a -> a #

minimum :: Ord a => Vector a -> a #

sum :: Num a => Vector a -> a #

product :: Num a => Vector a -> a #

Traversable Vector 
Instance details

Defined in Data.Vector

Methods

traverse :: Applicative f => (a -> f b) -> Vector a -> f (Vector b) #

sequenceA :: Applicative f => Vector (f a) -> f (Vector a) #

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

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

Eq1 Vector 
Instance details

Defined in Data.Vector

Methods

liftEq :: (a -> b -> Bool) -> Vector a -> Vector b -> Bool #

Ord1 Vector 
Instance details

Defined in Data.Vector

Methods

liftCompare :: (a -> b -> Ordering) -> Vector a -> Vector b -> Ordering #

Read1 Vector 
Instance details

Defined in Data.Vector

Methods

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

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Vector a] #

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Vector a) #

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Vector a] #

Show1 Vector 
Instance details

Defined in Data.Vector

Methods

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

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Vector a] -> ShowS #

MonadZip Vector 
Instance details

Defined in Data.Vector

Methods

mzip :: Vector a -> Vector b -> Vector (a, b) #

mzipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c #

munzip :: Vector (a, b) -> (Vector a, Vector b) #

Alternative Vector 
Instance details

Defined in Data.Vector

Methods

empty :: Vector a #

(<|>) :: Vector a -> Vector a -> Vector a #

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

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

MonadPlus Vector 
Instance details

Defined in Data.Vector

Methods

mzero :: Vector a #

mplus :: Vector a -> Vector a -> Vector a #

NFData1 Vector

Since: vector-0.12.1.0

Instance details

Defined in Data.Vector

Methods

liftRnf :: (a -> ()) -> Vector a -> () #

Zip Vector Source # 
Instance details

Defined in SDP.Vector

Methods

zap :: Vector (a -> b) -> Vector a -> Vector b #

all2 :: (a -> b -> Bool) -> Vector a -> Vector b -> Bool #

all3 :: (a -> b -> c -> Bool) -> Vector a -> Vector b -> Vector c -> Bool #

all4 :: (a -> b -> c -> d -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Bool #

all5 :: (a -> b -> c -> d -> e -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Bool #

all6 :: (a -> b -> c -> d -> e -> f -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Bool #

any2 :: (a -> b -> Bool) -> Vector a -> Vector b -> Bool #

any3 :: (a -> b -> c -> Bool) -> Vector a -> Vector b -> Vector c -> Bool #

any4 :: (a -> b -> c -> d -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Bool #

any5 :: (a -> b -> c -> d -> e -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Bool #

any6 :: (a -> b -> c -> d -> e -> f -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Bool #

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

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

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

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

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

zipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c #

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

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

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

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

Vector Vector a 
Instance details

Defined in Data.Vector

Methods

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

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

basicLength :: Vector a -> Int #

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

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

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

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

MonadIO io => Thaw io (Vector e) (MIOUnlist io e) Source # 
Instance details

Defined in SDP.Vector

Methods

thaw :: Vector e -> io (MIOUnlist io e) #

unsafeThaw :: Vector e -> io (MIOUnlist io e) #

MonadIO io => Thaw io (Vector e) (MIOArray# io e) Source # 
Instance details

Defined in SDP.Vector

Methods

thaw :: Vector e -> io (MIOArray# io e) #

unsafeThaw :: Vector e -> io (MIOArray# io e) #

MonadIO io => Freeze io (MIOUnlist io e) (Vector e) Source # 
Instance details

Defined in SDP.Vector

Methods

freeze :: MIOUnlist io e -> io (Vector e) #

unsafeFreeze :: MIOUnlist io e -> io (Vector e) #

MonadIO io => Freeze io (MIOArray# io e) (Vector e) Source # 
Instance details

Defined in SDP.Vector

Methods

freeze :: MIOArray# io e -> io (Vector e) #

unsafeFreeze :: MIOArray# io e -> io (Vector e) #

IsList (Vector a) 
Instance details

Defined in Data.Vector

Associated Types

type Item (Vector a) #

Methods

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

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

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

Eq a => Eq (Vector a) 
Instance details

Defined in Data.Vector

Methods

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

(/=) :: Vector a -> Vector a -> Bool #

Data a => Data (Vector a) 
Instance details

Defined in Data.Vector

Methods

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

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

toConstr :: Vector a -> Constr #

dataTypeOf :: Vector a -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

Ord a => Ord (Vector a) 
Instance details

Defined in Data.Vector

Methods

compare :: Vector a -> Vector a -> Ordering #

(<) :: Vector a -> Vector a -> Bool #

(<=) :: Vector a -> Vector a -> Bool #

(>) :: Vector a -> Vector a -> Bool #

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

max :: Vector a -> Vector a -> Vector a #

min :: Vector a -> Vector a -> Vector a #

Read a => Read (Vector a) 
Instance details

Defined in Data.Vector

Show a => Show (Vector a) 
Instance details

Defined in Data.Vector

Methods

showsPrec :: Int -> Vector a -> ShowS #

show :: Vector a -> String #

showList :: [Vector a] -> ShowS #

Semigroup (Vector a) 
Instance details

Defined in Data.Vector

Methods

(<>) :: Vector a -> Vector a -> Vector a #

sconcat :: NonEmpty (Vector a) -> Vector a #

stimes :: Integral b => b -> Vector a -> Vector a #

Monoid (Vector a) 
Instance details

Defined in Data.Vector

Methods

mempty :: Vector a #

mappend :: Vector a -> Vector a -> Vector a #

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

NFData a => NFData (Vector a) 
Instance details

Defined in Data.Vector

Methods

rnf :: Vector a -> () #

Nullable (Vector e) Source # 
Instance details

Defined in SDP.Vector

Methods

lzero :: Vector e #

isNull :: Vector e -> Bool #

Estimate (Vector e) Source # 
Instance details

Defined in SDP.Vector

Methods

(<.=>) :: Vector e -> Int -> Ordering #

(<==>) :: Compare (Vector e) #

(.==) :: Vector e -> Int -> Bool #

(./=) :: Vector e -> Int -> Bool #

(.<=) :: Vector e -> Int -> Bool #

(.>=) :: Vector e -> Int -> Bool #

(.<) :: Vector e -> Int -> Bool #

(.>) :: Vector e -> Int -> Bool #

(.<.) :: Vector e -> Vector e -> Bool #

(.>.) :: Vector e -> Vector e -> Bool #

(.<=.) :: Vector e -> Vector e -> Bool #

(.>=.) :: Vector e -> Vector e -> Bool #

(.==.) :: Vector e -> Vector e -> Bool #

(./=.) :: Vector e -> Vector e -> Bool #

Scan (Vector e) e Source # 
Instance details

Defined in SDP.Vector

Methods

scanl :: (b -> e -> b) -> b -> Vector e -> [b] #

scanl' :: (b -> e -> b) -> b -> Vector e -> [b] #

scanr :: (e -> b -> b) -> b -> Vector e -> [b] #

scanr' :: (e -> b -> b) -> b -> Vector e -> [b] #

scanl1 :: (e -> e -> e) -> Vector e -> [e] #

scanr1 :: (e -> e -> e) -> Vector e -> [e] #

Bordered (Vector e) Int Source # 
Instance details

Defined in SDP.Vector

Methods

bounds :: Vector e -> (Int, Int) #

lower :: Vector e -> Int #

upper :: Vector e -> Int #

sizeOf :: Vector e -> Int #

sizesOf :: Vector e -> [Int] #

indexIn :: Vector e -> Int -> Bool #

indices :: Vector e -> [Int] #

indexOf :: Vector e -> Int -> Int #

offsetOf :: Vector e -> Int -> Int #

Linear (Vector e) e Source # 
Instance details

Defined in SDP.Vector

Methods

uncons :: Vector e -> (e, Vector e) #

uncons' :: Vector e -> Maybe (e, Vector e) #

toHead :: e -> Vector e -> Vector e #

head :: Vector e -> e #

tail :: Vector e -> Vector e #

unsnoc :: Vector e -> (Vector e, e) #

unsnoc' :: Vector e -> Maybe (Vector e, e) #

toLast :: Vector e -> e -> Vector e #

init :: Vector e -> Vector e #

last :: Vector e -> e #

single :: e -> Vector e #

(++) :: Vector e -> Vector e -> Vector e #

replicate :: Int -> e -> Vector e #

fromList :: [e] -> Vector e #

fromListN :: Int -> [e] -> Vector e #

listR :: Vector e -> [e] #

listL :: Vector e -> [e] #

fromFoldable :: Foldable f => f e -> Vector e #

(!^) :: Vector e -> Int -> e #

write :: Vector e -> Int -> e -> Vector e #

concat :: Foldable f => f (Vector e) -> Vector e #

concatMap :: Foldable f => (a -> Vector e) -> f a -> Vector e #

intersperse :: e -> Vector e -> Vector e #

filter :: (e -> Bool) -> Vector e -> Vector e #

except :: (e -> Bool) -> Vector e -> Vector e #

partition :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

partitions :: Foldable f => f (e -> Bool) -> Vector e -> [Vector e] #

select :: (e -> Maybe a) -> Vector e -> [a] #

select' :: (t e ~ Vector e, Linear1 t a) => (e -> Maybe a) -> Vector e -> t a #

extract :: (e -> Maybe a) -> Vector e -> ([a], Vector e) #

extract' :: (t e ~ Vector e, Linear1 t a) => (e -> Maybe a) -> Vector e -> (t a, Vector e) #

selects :: Foldable f => f (e -> Maybe a) -> Vector e -> ([[a]], Vector e) #

selects' :: (Foldable f, t e ~ Vector e, Linear1 t a) => f (e -> Maybe a) -> Vector e -> ([t a], Vector e) #

isSubseqOf :: Vector e -> Vector e -> Bool #

reverse :: Vector e -> Vector e #

force :: Vector e -> Vector e #

subsequences :: Vector e -> [Vector e] #

iterate :: Int -> (e -> e) -> e -> Vector e #

nub :: Vector e -> Vector e #

nubBy :: Equal e -> Vector e -> Vector e #

ofoldr :: (Int -> e -> b -> b) -> b -> Vector e -> b #

ofoldl :: (Int -> b -> e -> b) -> b -> Vector e -> b #

ofoldr' :: (Int -> e -> b -> b) -> b -> Vector e -> b #

ofoldl' :: (Int -> b -> e -> b) -> b -> Vector e -> b #

o_foldr :: (e -> b -> b) -> b -> Vector e -> b #

o_foldl :: (b -> e -> b) -> b -> Vector e -> b #

o_foldr' :: (e -> b -> b) -> b -> Vector e -> b #

o_foldl' :: (b -> e -> b) -> b -> Vector e -> b #

Split (Vector e) e Source # 
Instance details

Defined in SDP.Vector

Methods

take :: Int -> Vector e -> Vector e #

drop :: Int -> Vector e -> Vector e #

keep :: Int -> Vector e -> Vector e #

sans :: Int -> Vector e -> Vector e #

save :: Int -> Vector e -> Vector e #

skip :: Int -> Vector e -> Vector e #

split :: Int -> Vector e -> (Vector e, Vector e) #

divide :: Int -> Vector e -> (Vector e, Vector e) #

splits :: Foldable f => f Int -> Vector e -> [Vector e] #

divides :: Foldable f => f Int -> Vector e -> [Vector e] #

parts :: Foldable f => f Int -> Vector e -> [Vector e] #

chunks :: Int -> Vector e -> [Vector e] #

splitBy :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

divideBy :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

splitsBy :: (e -> Bool) -> Vector e -> [Vector e] #

splitsOn :: Vector e -> Vector e -> [Vector e] #

replaceBy :: Vector e -> Vector e -> Vector e -> Vector e #

removeAll :: Vector e -> Vector e -> Vector e #

combo :: Equal e -> Vector e -> Int #

justifyL :: Int -> e -> Vector e -> Vector e #

justifyR :: Int -> e -> Vector e -> Vector e #

each :: Int -> Vector e -> Vector e #

eachFrom :: Int -> Int -> Vector e -> Vector e #

isPrefixOf :: Vector e -> Vector e -> Bool #

isSuffixOf :: Vector e -> Vector e -> Bool #

isInfixOf :: Vector e -> Vector e -> Bool #

prefix :: (e -> Bool) -> Vector e -> Int #

suffix :: (e -> Bool) -> Vector e -> Int #

infixes :: Vector e -> Vector e -> [Int] #

dropSide :: (e -> Bool) -> Vector e -> Vector e #

takeWhile :: (e -> Bool) -> Vector e -> Vector e #

dropWhile :: (e -> Bool) -> Vector e -> Vector e #

takeEnd :: (e -> Bool) -> Vector e -> Vector e #

dropEnd :: (e -> Bool) -> Vector e -> Vector e #

spanl :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

breakl :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

spanr :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

breakr :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

selectWhile :: (e -> Maybe a) -> Vector e -> [a] #

selectEnd :: (e -> Maybe a) -> Vector e -> [a] #

extractWhile :: (e -> Maybe a) -> Vector e -> ([a], Vector e) #

extractEnd :: (e -> Maybe a) -> Vector e -> (Vector e, [a]) #

selectWhile' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> t a #

selectEnd' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> t a #

extractWhile' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> (t a, Vector e) #

extractEnd' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> (Vector e, t a) #

Sort (Vector e) e Source # 
Instance details

Defined in SDP.Vector

Methods

sortedBy :: (e -> e -> Bool) -> Vector e -> Bool #

sortBy :: Compare e -> Vector e -> Vector e #

Indexed (Vector e) Int e Source # 
Instance details

Defined in SDP.Vector

Methods

assoc :: (Int, Int) -> [(Int, e)] -> Vector e #

assoc' :: (Int, Int) -> e -> [(Int, e)] -> Vector e #

fromIndexed :: Indexed m j e => m -> Vector e #

write' :: Vector e -> Int -> e -> Vector e #

accum :: (e -> e' -> e) -> Vector e -> [(Int, e')] -> Vector e #

imap :: Map m j e => (Int, Int) -> m -> (Int -> j) -> Vector e #

update' :: Vector e -> (e -> e) -> Int -> Vector e #

updates' :: Vector e -> (Int -> e -> e) -> Vector e #

Map (Vector e) Int e Source # 
Instance details

Defined in SDP.Vector

Methods

assocs :: Vector e -> [(Int, e)] #

toMap :: [(Int, e)] -> Vector e #

toMap' :: e -> [(Int, e)] -> Vector e #

insert' :: Int -> e -> Vector e -> Vector e #

delete' :: Int -> Vector e -> Vector e #

member' :: Int -> Vector e -> Bool #

(//) :: Vector e -> [(Int, e)] -> Vector e #

(.!) :: Vector e -> Int -> e #

(!) :: Vector e -> Int -> e #

(!?) :: Vector e -> Int -> Maybe e #

filter' :: (Int -> e -> Bool) -> Vector e -> Vector e #

union' :: (e -> e -> e) -> Vector e -> Vector e -> Vector e #

difference' :: (e -> e -> Maybe e) -> Vector e -> Vector e -> Vector e #

intersection' :: (e -> e -> e) -> Vector e -> Vector e -> Vector e #

update :: Vector e -> (Int -> e -> e) -> Vector e #

lookupLT' :: Int -> Vector e -> Maybe (Int, e) #

lookupGT' :: Int -> Vector e -> Maybe (Int, e) #

lookupLE' :: Int -> Vector e -> Maybe (Int, e) #

lookupGE' :: Int -> Vector e -> Maybe (Int, e) #

keys :: Vector e -> [Int] #

(.$) :: (e -> Bool) -> Vector e -> Maybe Int #

(*$) :: (e -> Bool) -> Vector e -> [Int] #

kfoldr :: (Int -> e -> b -> b) -> b -> Vector e -> b #

kfoldl :: (Int -> b -> e -> b) -> b -> Vector e -> b #

kfoldr' :: (Int -> e -> b -> b) -> b -> Vector e -> b #

kfoldl' :: (Int -> b -> e -> b) -> b -> Vector e -> b #

Thaw (ST s) (Vector e) (STUnlist s e) Source # 
Instance details

Defined in SDP.Vector

Methods

thaw :: Vector e -> ST s (STUnlist s e) #

unsafeThaw :: Vector e -> ST s (STUnlist s e) #

Thaw (ST s) (Vector e) (STArray# s e) Source # 
Instance details

Defined in SDP.Vector

Methods

thaw :: Vector e -> ST s (STArray# s e) #

unsafeThaw :: Vector e -> ST s (STArray# s e) #

Freeze (ST s) (STUnlist s e) (Vector e) Source # 
Instance details

Defined in SDP.Vector

Methods

freeze :: STUnlist s e -> ST s (Vector e) #

unsafeFreeze :: STUnlist s e -> ST s (Vector e) #

Freeze (ST s) (STArray# s e) (Vector e) Source # 
Instance details

Defined in SDP.Vector

Methods

freeze :: STArray# s e -> ST s (Vector e) #

unsafeFreeze :: STArray# s e -> ST s (Vector e) #

type Mutable Vector 
Instance details

Defined in Data.Vector

type Item (Vector a) 
Instance details

Defined in Data.Vector

type Item (Vector a) = a

Orphan instances

Zip Vector Source # 
Instance details

Methods

zap :: Vector (a -> b) -> Vector a -> Vector b #

all2 :: (a -> b -> Bool) -> Vector a -> Vector b -> Bool #

all3 :: (a -> b -> c -> Bool) -> Vector a -> Vector b -> Vector c -> Bool #

all4 :: (a -> b -> c -> d -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Bool #

all5 :: (a -> b -> c -> d -> e -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Bool #

all6 :: (a -> b -> c -> d -> e -> f -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Bool #

any2 :: (a -> b -> Bool) -> Vector a -> Vector b -> Bool #

any3 :: (a -> b -> c -> Bool) -> Vector a -> Vector b -> Vector c -> Bool #

any4 :: (a -> b -> c -> d -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Bool #

any5 :: (a -> b -> c -> d -> e -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Bool #

any6 :: (a -> b -> c -> d -> e -> f -> Bool) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Bool #

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

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

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

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

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

zipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c #

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

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

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

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

MonadIO io => Thaw io (Vector e) (MIOUnlist io e) Source # 
Instance details

Methods

thaw :: Vector e -> io (MIOUnlist io e) #

unsafeThaw :: Vector e -> io (MIOUnlist io e) #

MonadIO io => Thaw io (Vector e) (MIOArray# io e) Source # 
Instance details

Methods

thaw :: Vector e -> io (MIOArray# io e) #

unsafeThaw :: Vector e -> io (MIOArray# io e) #

MonadIO io => Freeze io (MIOUnlist io e) (Vector e) Source # 
Instance details

Methods

freeze :: MIOUnlist io e -> io (Vector e) #

unsafeFreeze :: MIOUnlist io e -> io (Vector e) #

MonadIO io => Freeze io (MIOArray# io e) (Vector e) Source # 
Instance details

Methods

freeze :: MIOArray# io e -> io (Vector e) #

unsafeFreeze :: MIOArray# io e -> io (Vector e) #

Nullable (Vector e) Source # 
Instance details

Methods

lzero :: Vector e #

isNull :: Vector e -> Bool #

Estimate (Vector e) Source # 
Instance details

Methods

(<.=>) :: Vector e -> Int -> Ordering #

(<==>) :: Compare (Vector e) #

(.==) :: Vector e -> Int -> Bool #

(./=) :: Vector e -> Int -> Bool #

(.<=) :: Vector e -> Int -> Bool #

(.>=) :: Vector e -> Int -> Bool #

(.<) :: Vector e -> Int -> Bool #

(.>) :: Vector e -> Int -> Bool #

(.<.) :: Vector e -> Vector e -> Bool #

(.>.) :: Vector e -> Vector e -> Bool #

(.<=.) :: Vector e -> Vector e -> Bool #

(.>=.) :: Vector e -> Vector e -> Bool #

(.==.) :: Vector e -> Vector e -> Bool #

(./=.) :: Vector e -> Vector e -> Bool #

Scan (Vector e) e Source # 
Instance details

Methods

scanl :: (b -> e -> b) -> b -> Vector e -> [b] #

scanl' :: (b -> e -> b) -> b -> Vector e -> [b] #

scanr :: (e -> b -> b) -> b -> Vector e -> [b] #

scanr' :: (e -> b -> b) -> b -> Vector e -> [b] #

scanl1 :: (e -> e -> e) -> Vector e -> [e] #

scanr1 :: (e -> e -> e) -> Vector e -> [e] #

Bordered (Vector e) Int Source # 
Instance details

Methods

bounds :: Vector e -> (Int, Int) #

lower :: Vector e -> Int #

upper :: Vector e -> Int #

sizeOf :: Vector e -> Int #

sizesOf :: Vector e -> [Int] #

indexIn :: Vector e -> Int -> Bool #

indices :: Vector e -> [Int] #

indexOf :: Vector e -> Int -> Int #

offsetOf :: Vector e -> Int -> Int #

Linear (Vector e) e Source # 
Instance details

Methods

uncons :: Vector e -> (e, Vector e) #

uncons' :: Vector e -> Maybe (e, Vector e) #

toHead :: e -> Vector e -> Vector e #

head :: Vector e -> e #

tail :: Vector e -> Vector e #

unsnoc :: Vector e -> (Vector e, e) #

unsnoc' :: Vector e -> Maybe (Vector e, e) #

toLast :: Vector e -> e -> Vector e #

init :: Vector e -> Vector e #

last :: Vector e -> e #

single :: e -> Vector e #

(++) :: Vector e -> Vector e -> Vector e #

replicate :: Int -> e -> Vector e #

fromList :: [e] -> Vector e #

fromListN :: Int -> [e] -> Vector e #

listR :: Vector e -> [e] #

listL :: Vector e -> [e] #

fromFoldable :: Foldable f => f e -> Vector e #

(!^) :: Vector e -> Int -> e #

write :: Vector e -> Int -> e -> Vector e #

concat :: Foldable f => f (Vector e) -> Vector e #

concatMap :: Foldable f => (a -> Vector e) -> f a -> Vector e #

intersperse :: e -> Vector e -> Vector e #

filter :: (e -> Bool) -> Vector e -> Vector e #

except :: (e -> Bool) -> Vector e -> Vector e #

partition :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

partitions :: Foldable f => f (e -> Bool) -> Vector e -> [Vector e] #

select :: (e -> Maybe a) -> Vector e -> [a] #

select' :: (t e ~ Vector e, Linear1 t a) => (e -> Maybe a) -> Vector e -> t a #

extract :: (e -> Maybe a) -> Vector e -> ([a], Vector e) #

extract' :: (t e ~ Vector e, Linear1 t a) => (e -> Maybe a) -> Vector e -> (t a, Vector e) #

selects :: Foldable f => f (e -> Maybe a) -> Vector e -> ([[a]], Vector e) #

selects' :: (Foldable f, t e ~ Vector e, Linear1 t a) => f (e -> Maybe a) -> Vector e -> ([t a], Vector e) #

isSubseqOf :: Vector e -> Vector e -> Bool #

reverse :: Vector e -> Vector e #

force :: Vector e -> Vector e #

subsequences :: Vector e -> [Vector e] #

iterate :: Int -> (e -> e) -> e -> Vector e #

nub :: Vector e -> Vector e #

nubBy :: Equal e -> Vector e -> Vector e #

ofoldr :: (Int -> e -> b -> b) -> b -> Vector e -> b #

ofoldl :: (Int -> b -> e -> b) -> b -> Vector e -> b #

ofoldr' :: (Int -> e -> b -> b) -> b -> Vector e -> b #

ofoldl' :: (Int -> b -> e -> b) -> b -> Vector e -> b #

o_foldr :: (e -> b -> b) -> b -> Vector e -> b #

o_foldl :: (b -> e -> b) -> b -> Vector e -> b #

o_foldr' :: (e -> b -> b) -> b -> Vector e -> b #

o_foldl' :: (b -> e -> b) -> b -> Vector e -> b #

Split (Vector e) e Source # 
Instance details

Methods

take :: Int -> Vector e -> Vector e #

drop :: Int -> Vector e -> Vector e #

keep :: Int -> Vector e -> Vector e #

sans :: Int -> Vector e -> Vector e #

save :: Int -> Vector e -> Vector e #

skip :: Int -> Vector e -> Vector e #

split :: Int -> Vector e -> (Vector e, Vector e) #

divide :: Int -> Vector e -> (Vector e, Vector e) #

splits :: Foldable f => f Int -> Vector e -> [Vector e] #

divides :: Foldable f => f Int -> Vector e -> [Vector e] #

parts :: Foldable f => f Int -> Vector e -> [Vector e] #

chunks :: Int -> Vector e -> [Vector e] #

splitBy :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

divideBy :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

splitsBy :: (e -> Bool) -> Vector e -> [Vector e] #

splitsOn :: Vector e -> Vector e -> [Vector e] #

replaceBy :: Vector e -> Vector e -> Vector e -> Vector e #

removeAll :: Vector e -> Vector e -> Vector e #

combo :: Equal e -> Vector e -> Int #

justifyL :: Int -> e -> Vector e -> Vector e #

justifyR :: Int -> e -> Vector e -> Vector e #

each :: Int -> Vector e -> Vector e #

eachFrom :: Int -> Int -> Vector e -> Vector e #

isPrefixOf :: Vector e -> Vector e -> Bool #

isSuffixOf :: Vector e -> Vector e -> Bool #

isInfixOf :: Vector e -> Vector e -> Bool #

prefix :: (e -> Bool) -> Vector e -> Int #

suffix :: (e -> Bool) -> Vector e -> Int #

infixes :: Vector e -> Vector e -> [Int] #

dropSide :: (e -> Bool) -> Vector e -> Vector e #

takeWhile :: (e -> Bool) -> Vector e -> Vector e #

dropWhile :: (e -> Bool) -> Vector e -> Vector e #

takeEnd :: (e -> Bool) -> Vector e -> Vector e #

dropEnd :: (e -> Bool) -> Vector e -> Vector e #

spanl :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

breakl :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

spanr :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

breakr :: (e -> Bool) -> Vector e -> (Vector e, Vector e) #

selectWhile :: (e -> Maybe a) -> Vector e -> [a] #

selectEnd :: (e -> Maybe a) -> Vector e -> [a] #

extractWhile :: (e -> Maybe a) -> Vector e -> ([a], Vector e) #

extractEnd :: (e -> Maybe a) -> Vector e -> (Vector e, [a]) #

selectWhile' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> t a #

selectEnd' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> t a #

extractWhile' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> (t a, Vector e) #

extractEnd' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> (Vector e, t a) #

Sort (Vector e) e Source # 
Instance details

Methods

sortedBy :: (e -> e -> Bool) -> Vector e -> Bool #

sortBy :: Compare e -> Vector e -> Vector e #

Indexed (Vector e) Int e Source # 
Instance details

Methods

assoc :: (Int, Int) -> [(Int, e)] -> Vector e #

assoc' :: (Int, Int) -> e -> [(Int, e)] -> Vector e #

fromIndexed :: Indexed m j e => m -> Vector e #

write' :: Vector e -> Int -> e -> Vector e #

accum :: (e -> e' -> e) -> Vector e -> [(Int, e')] -> Vector e #

imap :: Map m j e => (Int, Int) -> m -> (Int -> j) -> Vector e #

update' :: Vector e -> (e -> e) -> Int -> Vector e #

updates' :: Vector e -> (Int -> e -> e) -> Vector e #

Map (Vector e) Int e Source # 
Instance details

Methods

assocs :: Vector e -> [(Int, e)] #

toMap :: [(Int, e)] -> Vector e #

toMap' :: e -> [(Int, e)] -> Vector e #

insert' :: Int -> e -> Vector e -> Vector e #

delete' :: Int -> Vector e -> Vector e #

member' :: Int -> Vector e -> Bool #

(//) :: Vector e -> [(Int, e)] -> Vector e #

(.!) :: Vector e -> Int -> e #

(!) :: Vector e -> Int -> e #

(!?) :: Vector e -> Int -> Maybe e #

filter' :: (Int -> e -> Bool) -> Vector e -> Vector e #

union' :: (e -> e -> e) -> Vector e -> Vector e -> Vector e #

difference' :: (e -> e -> Maybe e) -> Vector e -> Vector e -> Vector e #

intersection' :: (e -> e -> e) -> Vector e -> Vector e -> Vector e #

update :: Vector e -> (Int -> e -> e) -> Vector e #

lookupLT' :: Int -> Vector e -> Maybe (Int, e) #

lookupGT' :: Int -> Vector e -> Maybe (Int, e) #

lookupLE' :: Int -> Vector e -> Maybe (Int, e) #

lookupGE' :: Int -> Vector e -> Maybe (Int, e) #

keys :: Vector e -> [Int] #

(.$) :: (e -> Bool) -> Vector e -> Maybe Int #

(*$) :: (e -> Bool) -> Vector e -> [Int] #

kfoldr :: (Int -> e -> b -> b) -> b -> Vector e -> b #

kfoldl :: (Int -> b -> e -> b) -> b -> Vector e -> b #

kfoldr' :: (Int -> e -> b -> b) -> b -> Vector e -> b #

kfoldl' :: (Int -> b -> e -> b) -> b -> Vector e -> b #

Thaw (ST s) (Vector e) (STUnlist s e) Source # 
Instance details

Methods

thaw :: Vector e -> ST s (STUnlist s e) #

unsafeThaw :: Vector e -> ST s (STUnlist s e) #

Thaw (ST s) (Vector e) (STArray# s e) Source # 
Instance details

Methods

thaw :: Vector e -> ST s (STArray# s e) #

unsafeThaw :: Vector e -> ST s (STArray# s e) #

Freeze (ST s) (STUnlist s e) (Vector e) Source # 
Instance details

Methods

freeze :: STUnlist s e -> ST s (Vector e) #

unsafeFreeze :: STUnlist s e -> ST s (Vector e) #

Freeze (ST s) (STArray# s e) (Vector e) Source # 
Instance details

Methods

freeze :: STArray# s e -> ST s (Vector e) #

unsafeFreeze :: STArray# s e -> ST s (Vector e) #