vector-static-0.3.0.1: Statically checked sizes on Data.Vector

Data.Vector.Static

Documentation

newtype Vec n a Source

Constructors

Vec
Fields unVec :: Vec n Vector a

Instances

Reify n => Monad (Vec n)
Functor (Vec n)
Reify n => Applicative (Vec n)
Foldable (Vec n)
(Reify n, Bounded a) => Bounded (Vec n a)
Eq a => Eq (Vec n a)
(Reify n, Floating a) => Floating (Vec n a)
(Reify n, Fractional a) => Fractional (Vec n a)
(Reify n, Num a) => Num (Vec n a)
Ord a => Ord (Vec n a)
Show a => Show (Vec n a)
(Reify n, Monoid a) => Monoid (Vec n a)

diagonal :: Reify n => Vec n (Vec n a) -> Vec n aSource

length :: Reify n => Vec n a -> Nat nSource

null :: forall n v a. Reify n => Vec n a -> Bool Source

empty :: Vec Z aSource

singleton :: a -> Vec (S Z) aSource

cons :: a -> Vec n a -> Vec (S n) aSource

snoc :: Vec n a -> a -> Vec (S n) aSource

replicate :: Reify n => a -> Vec n aSource

generate :: Reify n => (Fin n -> a) -> Vec n aSource

(++) :: Vec m a -> Vec n a -> Vec (m :+: n) aSource

copy :: Vec n a -> Vec n aSource

(!) :: Vec n a -> Fin n -> aSource

head :: Vec (S n) a -> aSource

last :: Vec (S n) a -> aSource

indexM :: Monad m => Vec n a -> Fin n -> m aSource

headM :: Monad m => Vec (S n) a -> m aSource

lastM :: Monad m => Vec (S n) a -> m aSource

slice :: Reify k => Fin n -> Vec (n :+: k) a -> Vec k aSource

init :: Vec (S n) a -> Vec n aSource

tail :: Vec (S n) a -> Vec n aSource

backpermute :: Vec m a -> Vec n (Fin m) -> Vec n aSource

reverse :: Vec n a -> Vec n aSource

map :: (a -> b) -> Vec n a -> Vec n bSource

imap :: (Fin n -> a -> b) -> Vec n a -> Vec n bSource

concatMap :: (a -> Vec n b) -> Vec m a -> Vec (m :*: n) bSource

zipWith :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n cSource

zipWith3 :: (a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n dSource

zipWith4 :: (a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n eSource

zipWith5 :: (a -> b -> c -> d -> e -> f) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n fSource

zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n gSource

izipWith :: (Fin n -> a -> b -> c) -> Vec n a -> Vec n b -> Vec n cSource

izipWith3 :: (Fin n -> a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n dSource

izipWith4 :: (Fin n -> a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n eSource

izipWith5 :: (Fin n -> a -> b -> c -> d -> e -> f) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n fSource

izipWith6 :: (Fin n -> a -> b -> c -> d -> e -> f -> g) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n gSource

zip :: Vec n a -> Vec n b -> Vec n (a, b)Source

zip3 :: Vec n a -> Vec n b -> Vec n c -> Vec n (a, b, c)Source

zip4 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n (a, b, c, d)Source

zip5 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n (a, b, c, d, e)Source

zip6 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n (a, b, c, d, e, f)Source

unzip :: Vec n (a, b) -> (Vec n a, Vec n b)Source

unzip3 :: Vec n (a, b, c) -> (Vec n a, Vec n b, Vec n c)Source

unzip4 :: Vec n (a, b, c, d) -> (Vec n a, Vec n b, Vec n c, Vec n d)Source

unzip5 :: Vec n (a, b, c, d, e) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e)Source

unzip6 :: Vec n (a, b, c, d, e, f) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e, Vec n f)Source

elem :: Eq a => a -> Vec n a -> Bool Source

notElem :: Eq a => a -> Vec n a -> Bool Source

find :: Eq a => (a -> Bool) -> Vec n a -> Maybe aSource

findIndex :: (a -> Bool) -> Vec n a -> Maybe (Fin n)Source

elemIndex :: Eq a => a -> Vec n a -> Maybe (Fin n)Source

foldl :: (a -> b -> a) -> a -> Vec n b -> aSource

foldl1 :: (a -> a -> a) -> Vec (S n) a -> aSource

foldl' :: (a -> b -> a) -> a -> Vec n b -> aSource

foldl1' :: (a -> a -> a) -> Vec (S n) a -> aSource

foldr :: (a -> b -> b) -> b -> Vec n a -> bSource

foldr1 :: (a -> a -> a) -> Vec (S n) a -> aSource

foldr' :: (a -> b -> b) -> b -> Vec n a -> bSource

foldr1' :: (a -> a -> a) -> Vec (S n) a -> aSource

ifoldl :: (a -> Fin n -> b -> a) -> a -> Vec n b -> aSource

ifoldl' :: (a -> Fin n -> b -> a) -> a -> Vec n b -> aSource

ifoldr :: (Fin n -> a -> b -> b) -> b -> Vec n a -> bSource

ifoldr' :: (Fin n -> a -> b -> b) -> b -> Vec n a -> bSource

all :: (a -> Bool) -> Vec n a -> Bool Source

any :: (a -> Bool) -> Vec n a -> Bool Source

and :: Vec n Bool -> Bool Source

or :: Vec n Bool -> Bool Source

sum :: Num a => Vec n a -> aSource

product :: Num a => Vec n a -> aSource

minimum :: Ord a => Vec (S n) a -> aSource

minimumBy :: (a -> a -> Ordering) -> Vec (S n) a -> aSource

minIndex :: Ord a => Vec (S n) a -> Fin (S n)Source

minIndexBy :: (a -> a -> Ordering) -> Vec (S n) a -> Fin (S n)Source

maximum :: Ord a => Vec (S n) a -> aSource

maximumBy :: (a -> a -> Ordering) -> Vec (S n) a -> aSource

maxIndex :: Ord a => Vec (S n) a -> Fin (S n)Source

maxIndexBy :: (a -> a -> Ordering) -> Vec (S n) a -> Fin (S n)Source

unfoldr :: (b -> Maybe (a, b)) -> b -> (forall n. Vec n a -> r) -> rSource

enumFromN :: forall a n. (Num a, Reify n) => a -> Vec n aSource

enumFromStepN :: forall a n. (Num a, Reify n) => a -> a -> Vec n aSource

toList :: Vec n a -> [a]Source

fromList :: [a] -> (forall n. Vec n a -> r) -> rSource

stream :: Vec n a -> Stream aSource

unstream :: Stream a -> (forall n. Vec n a -> r) -> rSource

streamR :: Vec n a -> Stream aSource

unstreamR :: Stream a -> (forall n. Vec n a -> r) -> rSource

new :: New a -> (forall n. Vec n a -> r) -> rSource

allFin :: Reify n => Vec n (Fin n)Source