Safe Haskell	None
Language	Haskell2010

Data.Vector.Generic.Sized

Contents

Construction
Monadic Construction
Elimination
Extract subsets
Mapping
Monadic Mapping
Folding

Synopsis

Documentation

data Vector v n a #

Instances

Foldable v => Foldable (Vector v n) #
Methods fold :: Monoid m => Vector v n m -> m # foldMap :: Monoid m => (a -> m) -> Vector v n a -> m # foldr :: (a -> b -> b) -> b -> Vector v n a -> b # foldr' :: (a -> b -> b) -> b -> Vector v n a -> b # foldl :: (b -> a -> b) -> b -> Vector v n a -> b # foldl' :: (b -> a -> b) -> b -> Vector v n a -> b # foldr1 :: (a -> a -> a) -> Vector v n a -> a # foldl1 :: (a -> a -> a) -> Vector v n a -> a # toList :: Vector v n a -> [a] # null :: Vector v n a -> Bool # length :: Vector v n a -> Int # elem :: Eq a => a -> Vector v n a -> Bool # maximum :: Ord a => Vector v n a -> a # minimum :: Ord a => Vector v n a -> a # sum :: Num a => Vector v n a -> a # product :: Num a => Vector v n a -> a #
Eq (v a) => Eq (Vector v n a) #
Methods (==) :: Vector v n a -> Vector v n a -> Bool # (/=) :: Vector v n a -> Vector v n a -> Bool #
Ord (v a) => Ord (Vector v n a) #
Methods compare :: Vector v n a -> Vector v n a -> Ordering # (<) :: Vector v n a -> Vector v n a -> Bool # (<=) :: Vector v n a -> Vector v n a -> Bool # (>) :: Vector v n a -> Vector v n a -> Bool # (>=) :: Vector v n a -> Vector v n a -> Bool # max :: Vector v n a -> Vector v n a -> Vector v n a # min :: Vector v n a -> Vector v n a -> Vector v n a #
Show (v a) => Show (Vector v n a) #
Methods showsPrec :: Int -> Vector v n a -> ShowS # show :: Vector v n a -> String # showList :: [Vector v n a] -> ShowS #
(KnownNat n, Storable a) => Storable (Vector Vector n a) #
Methods sizeOf :: Vector Vector n a -> Int # alignment :: Vector Vector n a -> Int # peekElemOff :: Ptr (Vector Vector n a) -> Int -> IO (Vector Vector n a) # pokeElemOff :: Ptr (Vector Vector n a) -> Int -> Vector Vector n a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Vector Vector n a) # pokeByteOff :: Ptr b -> Int -> Vector Vector n a -> IO () # peek :: Ptr (Vector Vector n a) -> IO (Vector Vector n a) # poke :: Ptr (Vector Vector n a) -> Vector Vector n a -> IO () #
NFData (v a) => NFData (Vector v n a) #
Methods rnf :: Vector v n a -> () #

Construction

fromVector :: forall a v n. (KnownNat n, Vector v a) => v a -> Maybe (Vector v n a) #

Convert a Vector into a Vector if it has the correct size, otherwise return Nothing.

replicate :: forall a v n. (Vector v a, KnownNat n) => a -> Vector v n a #

O(n) Construct a vector with the same element in each position.

singleton :: forall a v. Vector v a => a -> Vector v 1 a #

O(1) construct a single element vector.

generate :: forall n a v. (Vector v a, KnownNat n) => Proxy n -> (Int -> a) -> Vector v n a #

O(n) construct a vector of the given length by applying the function to each index.

Monadic Construction

generateM :: forall n a v m. (Vector v a, KnownNat n, Monad m) => Proxy n -> (Int -> m a) -> m (Vector v n a) #

O(n) construct a vector of the given length by applying the monadic action to each index.

Elimination

length :: forall a v n. Vector v a => Vector v n a -> Int #

O(1) Get the length of the vector.

index :: forall m a v n. (KnownNat n, KnownNat m, Vector v a) => Vector v (m + n) a -> Proxy n -> a #

O(1) Index safely into the vector using a type level index.

head :: forall a v n. Vector v a => Vector v (n + 1) a -> a #

O(1) Get the first element of a non-empty vector.

last :: forall a v n. Vector v a => Vector v (n + 1) a -> a #

O(1) Get the last element of a non-empty vector.

Extract subsets

tail :: forall a v n. Vector v a => Vector v (n + 1) a -> Vector v n a #

O(1) Yield all but the first element of a non-empty vector without copying.

init :: forall a v n. Vector v a => Vector v (n + 1) a -> Vector v n a #

O(1) Yield all but the last element of a non-empty vector without copying.

take :: forall m a v n. (KnownNat n, KnownNat m, Vector v a) => Proxy n -> Vector v (m + n) a -> Vector v n a #

O(1) Yield the first n elements. The resultant vector always contains this many elements.

drop :: forall m a v n. (KnownNat n, KnownNat m, Vector v a) => Proxy n -> Vector v (m + n) a -> Vector v m a #

O(1) Yield all but the first n elements.

Mapping

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

O(n) Map a function over the vector.

Monadic Mapping

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

O(n) Apply the monadic action to every element of a vector and its index, ignoring the results.

Folding

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

O(n) Left fold with a strict accumulator.

foldl1' :: forall a v n. Vector v a => (a -> a -> a) -> Vector v (n + 1) a -> a #

O(n) Left fold on a non-empty vector with a strict accumulator.