Data.StrictVector

Documentation

module Data.Vector.Generic

data Vector a

Instances

Monad Vector

Methods

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

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

return :: a -> Vector a

fail :: String -> Vector a

Functor Vector

Methods

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

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

MonadFail Vector

Methods

fail :: String -> Vector a

Applicative Vector

Methods

pure :: a -> Vector a

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

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

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

Foldable Vector

Methods

fold :: Monoid m => Vector m -> 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

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)

Alternative Vector

Methods

empty :: Vector a

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

some :: Vector a -> Vector [a]

many :: Vector a -> Vector [a]

MonadPlus Vector

Methods

mzero :: Vector a

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

Vector Vector a

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

IsList (Vector a)

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)

Methods

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

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

Data a => Data (Vector a)

Methods

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

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

toConstr :: Vector a -> Constr

dataTypeOf :: Vector a -> DataType

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (Vector a)

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)

Methods

readsPrec :: Int -> ReadS (Vector a)

readList :: ReadS [Vector a]

readPrec :: ReadPrec (Vector a)

readListPrec :: ReadPrec [Vector a]

Show a => Show (Vector a)

Methods

showsPrec :: Int -> Vector a -> ShowS

show :: Vector a -> String

showList :: [Vector a] -> ShowS

Monoid (Vector a)

Methods

mempty :: Vector a

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

mconcat :: [Vector a] -> Vector a

Arbitrary a => Arbitrary (Vector a)

Methods

arbitrary :: Gen (Vector a)

shrink :: Vector a -> [Vector a]

Hashable a => Hashable (Vector a)

Methods

hashWithSalt :: Int -> Vector a -> Int

hash :: Vector a -> Int

ToJSON a => ToJSON (Vector a)

Methods

toJSON :: Vector a -> Value

toEncoding :: Vector a -> Encoding

toJSONList :: [Vector a] -> Value

toEncodingList :: [Vector a] -> Encoding

FromJSON a => FromJSON (Vector a)

Methods

parseJSON :: Value -> Parser (Vector a)

parseJSONList :: Value -> Parser [Vector a]

NFData a => NFData (Vector a)

Methods

rnf :: Vector a -> ()

type Mutable Vector

type Mutable Vector = MVector

type Item (Vector a)

type Item (Vector a) = a

null :: Vector a -> Bool

O(1) Test whether a vector if empty

length :: Vector a -> Int

O(1) Yield the length of the vector.

(!) :: Vector a -> Int -> a

O(1) Indexing

(!?) :: Vector a -> Int -> Maybe a

O(1) Safe indexing

head :: Vector a -> a

O(1) First element

last :: Vector a -> a

O(1) Last element

fromList :: [a] -> Vector a

fromListN :: Int -> [a] -> Vector a

toList :: Vector a -> [a]

empty :: Vector a

singleton :: a -> Vector a

generate :: Int -> (Int -> a) -> Vector a

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

catMaybes :: Vector (Maybe a) -> Vector a

mapMaybe :: (a -> Maybe b) -> Vector a -> Vector b

lastMay :: Vector a -> Maybe a

toHashSet :: (Eq a, Hashable a) => Vector a -> HashSet a

lookAround :: Vector a -> Vector (Maybe a, a, Maybe a)

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

dropWhileLookingAround :: (Maybe a -> a -> Maybe a -> Bool) -> Vector a -> Vector a

fromSL :: SL a -> Vector a

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

binarySearchL :: (e -> Ordering) -> Vector e -> Int

binarySearchR :: (e -> Ordering) -> Vector e -> Int

sort :: Ord a => Vector a -> Vector a

sortBy :: (a -> a -> Ordering) -> Vector a -> Vector a

sortOn :: Ord b => (a -> b) -> Vector a -> Vector a

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

groupOn :: Eq b => (a -> b) -> Vector a -> Vector (b, Vector a)

toSL :: Vector a -> SL a

uncons :: Vector a -> Option (a, Vector a)

updateVector :: Int -> a -> a -> Vector a -> Vector a

updateVectorWith :: Int -> a -> (a -> a) -> Vector a -> Vector a

unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> m (Vector a)

unfoldrNM :: Monad m => Int -> (s -> m (Maybe (a, s))) -> s -> m (Vector a)

theOnlyOne :: Vector a -> Maybe a

Returns Just the only element of the vector if there is exactly one element or Nothing otherwise.