-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Statically checked sizes on Data.Vector
--   
--   Very unstable! Many interfaces are still incomplete or even empty. Nat
--   and Fin will be moving to a separate package eventually.
@package vector-static
@version 0.2.0

module Data.Vector.Storable.Mutable.Static

module Data.Vector.Unboxed.Mutable.Static

module Data.Vector.Mutable.Static

module Data.Nat
newtype I x
I :: x -> I x
unI :: I x -> x
newtype K x y
K :: x -> K x y
unK :: K x y -> x
data Z
data S n
newtype Nat n
Nat :: Int -> Nat n
z :: Nat Z
s :: Nat n -> Nat (S n)
natToInt :: Nat n -> Int
data Reifiable n
Proof :: Reifiable n
data Exists
Ex :: !Reifiable n -> Exists
reifiable :: Nat n -> Reifiable n
class Reify n
witnessNat :: (Reify n) => Nat n
addNat :: Nat a -> Nat b -> Nat (a :+: b)
mulNat :: Nat a -> Nat b -> Nat (a :*: b)
data NatView n
Zero :: NatView Z
Succ :: Nat n -> NatView (S n)
view :: Nat n -> NatView n
instance (Reify n) => Reify (S n)
instance Reify Z
instance Show (Nat n)

module Data.Fin
newtype Fin n
Fin :: Int -> Fin n
zero :: Fin (S n)
succ :: Fin n -> Fin (S n)
pred :: Fin n -> Fin n
addFin :: Fin x -> Fin y -> Fin (x :+: y)
mulFin :: Fin x -> Fin y -> Fin (x :*: y)
mulNatFin :: Nat x -> Fin (S y) -> Fin (S (x :*: y))
raise :: k -> Fin n -> Fin (n :+: k)
intToFin :: Int -> Nat n -> Maybe (Fin n)
finToInt :: Fin n -> Int
natToFin :: Nat n -> Fin (S n)
instance Show (Fin n)
instance Eq (Fin n)
instance Ord (Fin n)

module Data.Vector.Unboxed.Fin
instance Unbox (Fin n)
instance (MVector v Int) => MVector v (Fin n)
instance (Vector v Int) => Vector v (Fin n)

module Data.Vector.Generic.Static
newtype Vec n v a
Vec :: v a -> Vec n v a
unVec :: Vec n v a -> v a
length :: (Vector v a) => Vec n v a -> Nat n
empty :: (Vector v a) => Vec Z v a
singleton :: (Vector v a) => a -> Vec (S Z) v a
cons :: (Vector v a) => a -> Vec n v a -> Vec (S n) v a
snoc :: (Vector v a) => Vec n v a -> a -> Vec (S n) v a
replicate :: (Vector v a) => Nat n -> a -> Vec n v a
generate :: (Vector v a) => Nat n -> (Fin n -> a) -> Vec n v a
(++) :: (Vector v a) => Vec m v a -> Vec n v a -> Vec (m :+: n) v a
copy :: (Vector v a) => Vec n v a -> Vec n v a
(!) :: (Vector v a) => Vec n v a -> Fin n -> a
head :: (Vector v a) => Vec (S n) v a -> a
last :: (Vector v a) => Vec (S n) v a -> a
slice :: (Vector v a) => Fin n -> Nat k -> Vec (n :+: k) v a -> Vec k v a
init :: (Vector v a) => Vec (S n) v a -> Vec n v a
tail :: (Vector v a) => Vec (S n) v a -> Vec n v a
take :: (Vector v a) => Nat k -> Vec (n :+: k) v a -> Vec k v a
drop :: (Vector v a) => Nat k -> Vec (n :+: k) v a -> Vec n v a
backpermute :: (Vector v a, Vector v Int) => Vec m v a -> Vec n v (Fin m) -> Vec n v a
reverse :: (Vector v a) => Vec n v a -> Vec n v a
map :: (Vector v a, Vector v b) => (a -> b) -> Vec n v a -> Vec n v b
imap :: (Vector v a, Vector v b) => (Fin n -> a -> b) -> Vec n v a -> Vec n v b
concatMap :: (Vector v a, Vector v b) => (a -> Vec n v b) -> Vec m v a -> Vec (m :*: n) v b
zipWith :: (Vector v a, Vector v b, Vector v c) => (a -> b -> c) -> Vec n v a -> Vec n v b -> Vec n v c
zipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (a -> b -> c -> d) -> Vec n v a -> Vec n v b -> Vec n v c -> Vec n v d
zipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (a -> b -> c -> d -> e) -> Vec n v a -> Vec n v b -> Vec n v c -> Vec n v d -> Vec n 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) -> Vec n v a -> Vec n v b -> Vec n v c -> Vec n v d -> Vec n v e -> Vec n 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) -> Vec n v a -> Vec n v b -> Vec n v c -> Vec n v d -> Vec n v e -> Vec n v f -> Vec n v g
izipWith :: (Vector v a, Vector v b, Vector v c) => (Fin n -> a -> b -> c) -> Vec n v a -> Vec n v b -> Vec n v c
izipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (Fin n -> a -> b -> c -> d) -> Vec n v a -> Vec n v b -> Vec n v c -> Vec n v d
izipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (Fin n -> a -> b -> c -> d -> e) -> Vec n v a -> Vec n v b -> Vec n v c -> Vec n v d -> Vec n v e
izipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f) => (Fin n -> a -> b -> c -> d -> e -> f) -> Vec n v a -> Vec n v b -> Vec n v c -> Vec n v d -> Vec n v e -> Vec n v f
izipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g) => (Fin n -> a -> b -> c -> d -> e -> f -> g) -> Vec n v a -> Vec n v b -> Vec n v c -> Vec n v d -> Vec n v e -> Vec n v f -> Vec n v g
zip :: (Vector v a, Vector v b, Vector v (a, b)) => Vec n v a -> Vec n v b -> Vec n v (a, b)
zip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => Vec n v a -> Vec n v b -> Vec n v c -> Vec n v (a, b, c)
zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => Vec n v a -> Vec n v b -> Vec n v c -> Vec n v d -> Vec n 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)) => Vec n v a -> Vec n v b -> Vec n v c -> Vec n v d -> Vec n v e -> Vec n 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)) => Vec n v a -> Vec n v b -> Vec n v c -> Vec n v d -> Vec n v e -> Vec n v f -> Vec n v (a, b, c, d, e, f)
unzip :: (Vector v a, Vector v b, Vector v (a, b)) => Vec n v (a, b) -> (Vec n v a, Vec n v b)
unzip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => Vec n v (a, b, c) -> (Vec n v a, Vec n v b, Vec n v c)
unzip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => Vec n v (a, b, c, d) -> (Vec n v a, Vec n v b, Vec n v c, Vec n 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)) => Vec n v (a, b, c, d, e) -> (Vec n v a, Vec n v b, Vec n v c, Vec n v d, Vec n 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)) => Vec n v (a, b, c, d, e, f) -> (Vec n v a, Vec n v b, Vec n v c, Vec n v d, Vec n v e, Vec n v f)
elem :: (Vector v a, Eq a) => a -> Vec n v a -> Bool
notElem :: (Vector v a, Eq a) => a -> Vec n v a -> Bool
find :: (Vector v a, Eq a) => (a -> Bool) -> Vec n v a -> Maybe a
findIndex :: (Vector v a) => (a -> Bool) -> Vec n v a -> Maybe (Fin n)
findIndices :: (Vector v a, Vector v Int, Vector v (Fin n)) => (a -> Bool) -> Vec n v a -> Vec m v (Fin n)
elemIndex :: (Vector v a) => (Eq a) => a -> Vec n v a -> Maybe (Fin n)
elemIndices :: (Vector v a, Vector v Int, Vector v (Fin n)) => (Eq a) => a -> Vec n v a -> Vec m v (Fin n)
foldl :: (Vector v b) => (a -> b -> a) -> a -> Vec n v b -> a
foldl1 :: (Vector v a) => (a -> a -> a) -> Vec (S n) v a -> a
foldl' :: (Vector v b) => (a -> b -> a) -> a -> Vec n v b -> a
foldl1' :: (Vector v a) => (a -> a -> a) -> Vec (S n) v a -> a
foldr :: (Vector v a) => (a -> b -> b) -> b -> Vec n v a -> b
foldr1 :: (Vector v a) => (a -> a -> a) -> Vec (S n) v a -> a
foldr' :: (Vector v a) => (a -> b -> b) -> b -> Vec n v a -> b
foldr1' :: (Vector v a) => (a -> a -> a) -> Vec (S n) v a -> a
ifoldl :: (Vector v b) => (a -> Fin n -> b -> a) -> a -> Vec n v b -> a
ifoldl' :: (Vector v b) => (a -> Fin n -> b -> a) -> a -> Vec n v b -> a
ifoldr :: (Vector v a) => (Fin n -> a -> b -> b) -> b -> Vec n v a -> b
ifoldr' :: (Vector v a) => (Fin n -> a -> b -> b) -> b -> Vec n v a -> b
all :: (Vector v a) => (a -> Bool) -> Vec n v a -> Bool
any :: (Vector v a) => (a -> Bool) -> Vec n v a -> Bool
and :: (Vector v Bool) => Vec n v Bool -> Bool
or :: (Vector v Bool) => Vec n v Bool -> Bool
sum :: (Vector v a, Num a) => Vec n v a -> a
product :: (Vector v a, Num a) => Vec n v a -> a
minimum :: (Ord a, Vector v a) => Vec (S n) v a -> a
minimumBy :: (Vector v a) => (a -> a -> Ordering) -> Vec (S n) v a -> a
minIndex :: (Ord a, Vector v a) => Vec (S n) v a -> Fin (S n)
minIndexBy :: (Vector v a) => (a -> a -> Ordering) -> Vec (S n) v a -> Fin (S n)
maximum :: (Ord a, Vector v a) => Vec (S n) v a -> a
maximumBy :: (Vector v a) => (a -> a -> Ordering) -> Vec (S n) v a -> a
maxIndex :: (Ord a, Vector v a) => Vec (S n) v a -> Fin (S n)
maxIndexBy :: (Vector v a) => (a -> a -> Ordering) -> Vec (S n) v a -> Fin (S n)
unfoldr :: (Vector v a) => (b -> Maybe (a, b)) -> b -> (forall n. Vec n v a -> r) -> r
enumFromN :: (Vector v a, Num a) => a -> Nat n -> Vec n v a
enumFromStepN :: (Vector v a, Num a) => a -> a -> Nat n -> Vec n v a
toList :: (Vector v a) => Vec n v a -> [a]
fromList :: (Vector v a) => [a] -> (forall n. Vec n v a -> r) -> r
stream :: (Vector v a) => Vec n v a -> Stream a
unstream :: (Vector v a) => Stream a -> (forall n. Vec n v a -> r) -> r
streamR :: (Vector v a) => Vec n v a -> Stream a
unstreamR :: (Vector v a) => Stream a -> (forall n. Vec n v a -> r) -> r
new :: (Vector v a) => New a -> (forall n. Vec n v a -> r) -> r
allFin :: (Vector v (Fin n)) => Nat n -> Vec n v (Fin n)
indexed :: (Vector v a, Vector v (Fin n, a)) => Vec n v a -> Vec n v (Fin n, a)
instance (Show (v a)) => Show (Vec n v a)
instance (Eq (v a)) => Eq (Vec n v a)
instance (Ord (v a)) => Ord (Vec n v a)

module Data.Vector.Generic.Mutable.Static
newtype MVec n v s a
MVec :: v s a -> MVec n v s a
unVec :: MVec n v s a -> v s a
overlaps :: (MVector v a) => MVec n v s a -> MVec n v s a -> Bool
new :: (PrimMonad m, MVector v a) => Nat n -> m (MVec n v (PrimState m) a)
newWith :: (PrimMonad m, MVector v a) => Nat n -> a -> m (MVec n v (PrimState m) a)
read :: (PrimMonad m, MVector v a) => MVec n v (PrimState m) a -> Fin n -> m a
write :: (PrimMonad m, MVector v a) => MVec n v (PrimState m) a -> Fin n -> a -> m ()
swap :: (PrimMonad m, MVector v a) => MVec n v (PrimState m) a -> Fin n -> Fin n -> m ()
clear :: (PrimMonad m, MVector v a) => MVec n v (PrimState m) a -> m ()
set :: (PrimMonad m, MVector v a) => MVec n v (PrimState m) a -> a -> m ()
copy :: (PrimMonad m, MVector v a) => MVec n v (PrimState m) a -> MVec n v (PrimState m) a -> m ()
grow :: (PrimMonad m, MVector v a) => MVec n v (PrimState m) a -> Nat k -> m (MVec (n :+: k) v (PrimState m) a)
slice :: (MVector v a) => Fin n -> Nat k -> MVec (n :+: k) v s a -> MVec k v s a
take :: (MVector v a) => Nat k -> MVec (n :+: k) v s a -> MVec k v s a
drop :: (MVector v a) => Nat k -> MVec (n :+: k) v s a -> MVec n v s a
init :: (MVector v a) => MVec (S n) v s a -> MVec n v s a
tail :: (MVector v a) => MVec (S n) v s a -> MVec n v s a
instance (Show (v s a)) => Show (MVec n v s a)
instance (Eq (v s a)) => Eq (MVec n v s a)

module Data.Vector.Static
newtype Vec n a
Vec :: Vec n Vector a -> Vec n a
unVec :: Vec n a -> Vec n Vector a
diagonal :: Vec n (Vec n a) -> Vec n a
length :: Vec n a -> Nat n
empty :: Vec Z a
singleton :: a -> Vec (S Z) a
cons :: a -> Vec n a -> Vec (S n) a
snoc :: Vec n a -> a -> Vec (S n) a
replicate :: Nat n -> a -> Vec n a
generate :: Nat n -> (Fin n -> a) -> Vec n a
(++) :: Vec m a -> Vec n a -> Vec (m :+: n) a
copy :: Vec n a -> Vec n a
(!) :: Vec n a -> Fin n -> a
head :: Vec (S n) a -> a
last :: Vec (S n) a -> a
init :: Vec (S n) a -> Vec n a
tail :: Vec (S n) a -> Vec n a
backpermute :: Vec m a -> Vec n (Fin m) -> Vec n a
reverse :: Vec n a -> Vec n a
map :: (a -> b) -> Vec n a -> Vec n b
imap :: (Fin n -> a -> b) -> Vec n a -> Vec n b
concatMap :: (a -> Vec n b) -> Vec m a -> Vec (m :*: n) b
zipWith :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
zipWith3 :: (a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n d
zipWith4 :: (a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e
zipWith5 :: (a -> b -> c -> d -> e -> f) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f
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 g
izipWith :: (Fin n -> a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
izipWith3 :: (Fin n -> a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n d
izipWith4 :: (Fin n -> a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e
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 f
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 g
zip :: Vec n a -> Vec n b -> Vec n (a, b)
zip3 :: Vec n a -> Vec n b -> Vec n c -> Vec n (a, b, c)
zip4 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n (a, b, c, d)
zip5 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n (a, b, c, d, e)
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)
unzip :: Vec n (a, b) -> (Vec n a, Vec n b)
unzip3 :: Vec n (a, b, c) -> (Vec n a, Vec n b, Vec n c)
unzip4 :: Vec n (a, b, c, d) -> (Vec n a, Vec n b, Vec n c, Vec n d)
unzip5 :: Vec n (a, b, c, d, e) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e)
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)
elem :: (Eq a) => a -> Vec n a -> Bool
notElem :: (Eq a) => a -> Vec n a -> Bool
find :: (Eq a) => (a -> Bool) -> Vec n a -> Maybe a
findIndex :: (a -> Bool) -> Vec n a -> Maybe (Fin n)
findIndices :: (a -> Bool) -> Vec n a -> Vec m (Fin n)
elemIndex :: (Eq a) => a -> Vec n a -> Maybe (Fin n)
elemIndices :: (Eq a) => a -> Vec n a -> Vec m (Fin n)
foldl :: (a -> b -> a) -> a -> Vec n b -> a
foldl1 :: (a -> a -> a) -> Vec (S n) a -> a
foldl' :: (a -> b -> a) -> a -> Vec n b -> a
foldl1' :: (a -> a -> a) -> Vec (S n) a -> a
foldr :: (a -> b -> b) -> b -> Vec n a -> b
foldr1 :: (a -> a -> a) -> Vec (S n) a -> a
foldr' :: (a -> b -> b) -> b -> Vec n a -> b
foldr1' :: (a -> a -> a) -> Vec (S n) a -> a
ifoldl :: (a -> Fin n -> b -> a) -> a -> Vec n b -> a
ifoldl' :: (a -> Fin n -> b -> a) -> a -> Vec n b -> a
ifoldr :: (Fin n -> a -> b -> b) -> b -> Vec n a -> b
ifoldr' :: (Fin n -> a -> b -> b) -> b -> Vec n a -> b
all :: (a -> Bool) -> Vec n a -> Bool
any :: (a -> Bool) -> Vec n a -> Bool
and :: Vec n Bool -> Bool
or :: Vec n Bool -> Bool
sum :: (Num a) => Vec n a -> a
product :: (Num a) => Vec n a -> a
minimum :: (Ord a) => Vec (S n) a -> a
minimumBy :: (a -> a -> Ordering) -> Vec (S n) a -> a
minIndex :: (Ord a) => Vec (S n) a -> Fin (S n)
minIndexBy :: (a -> a -> Ordering) -> Vec (S n) a -> Fin (S n)
maximum :: (Ord a) => Vec (S n) a -> a
maximumBy :: (a -> a -> Ordering) -> Vec (S n) a -> a
maxIndex :: (Ord a) => Vec (S n) a -> Fin (S n)
maxIndexBy :: (a -> a -> Ordering) -> Vec (S n) a -> Fin (S n)
unfoldr :: (b -> Maybe (a, b)) -> b -> (forall n. Vec n a -> r) -> r
enumFromN :: (Num a) => a -> Nat n -> Vec n a
enumFromStepN :: (Num a) => a -> a -> Nat n -> Vec n a
toList :: Vec n a -> [a]
fromList :: [a] -> (forall n. Vec n a -> r) -> r
stream :: Vec n a -> Stream a
unstream :: Stream a -> (forall n. Vec n a -> r) -> r
streamR :: Vec n a -> Stream a
unstreamR :: Stream a -> (forall n. Vec n a -> r) -> r
new :: New a -> (forall n. Vec n a -> r) -> r
allFin :: Nat n -> Vec n (Fin n)
instance (Eq a) => Eq (Vec n a)
instance (Ord a) => Ord (Vec n a)
instance (Show a) => Show (Vec n a)
instance (Reify n, Floating a) => Floating (Vec n a)
instance (Reify n, Fractional a) => Fractional (Vec n a)
instance (Reify n, Num a) => Num (Vec n a)
instance (Reify n, Bounded a) => Bounded (Vec n a)
instance (Reify n, Monoid a) => Monoid (Vec n a)
instance Foldable (Vec n)
instance (Reify n) => Monad (Vec n)
instance (Reify n) => Applicative (Vec n)
instance Functor (Vec n)

module Data.Vector.Unboxed.Static
newtype Vec n a
Vec :: Vec n Vector a -> Vec n a
unVec :: Vec n a -> Vec n Vector a
length :: (Unbox a) => Vec n a -> Nat n
empty :: (Unbox a) => Vec Z a
singleton :: (Unbox a) => a -> Vec (S Z) a
cons :: (Unbox a) => a -> Vec n a -> Vec (S n) a
snoc :: (Unbox a) => Vec n a -> a -> Vec (S n) a
replicate :: (Unbox a) => Nat n -> a -> Vec n a
generate :: (Unbox a) => Nat n -> (forall m. (n ~ (S m)) => Fin n -> a) -> Vec n a
(++) :: (Unbox a) => Vec m a -> Vec n a -> Vec (m :+: n) a
copy :: (Unbox a) => Vec n a -> Vec n a
(!) :: (Unbox a) => Vec n a -> Fin n -> a
head :: (Unbox a) => Vec (S n) a -> a
last :: (Unbox a) => Vec (S n) a -> a
init :: (Unbox a) => Vec (S n) a -> Vec n a
tail :: (Unbox a) => Vec (S n) a -> Vec n a
backpermute :: (Unbox a) => Vec m a -> Vec n (Fin m) -> Vec n a
reverse :: (Unbox a) => Vec n a -> Vec n a
map :: (Unbox a, Unbox b) => (a -> b) -> Vec n a -> Vec n b
imap :: (Unbox a, Unbox b) => (Fin n -> a -> b) -> Vec n a -> Vec n b
concatMap :: (Unbox a, Unbox b) => (a -> Vec n b) -> Vec m a -> Vec (m :*: n) b
zipWith :: (Unbox a, Unbox b, Unbox c) => (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
zipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => (a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n d
zipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e
zipWith5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => (a -> b -> c -> d -> e -> f) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f
zipWith6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => (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 g
izipWith :: (Unbox a, Unbox b, Unbox c) => (Fin n -> a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
izipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => (Fin n -> a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n d
izipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (Fin n -> a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e
izipWith5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => (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 f
izipWith6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => (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 g
zip :: (Unbox a, Unbox b) => Vec n a -> Vec n b -> Vec n (a, b)
zip3 :: (Unbox a, Unbox b, Unbox c) => Vec n a -> Vec n b -> Vec n c -> Vec n (a, b, c)
zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n (a, b, c, d)
zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n (a, b, c, d, e)
zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => 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)
unzip :: (Unbox a, Unbox b) => Vec n (a, b) -> (Vec n a, Vec n b)
unzip3 :: (Unbox a, Unbox b, Unbox c) => Vec n (a, b, c) -> (Vec n a, Vec n b, Vec n c)
unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vec n (a, b, c, d) -> (Vec n a, Vec n b, Vec n c, Vec n d)
unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vec n (a, b, c, d, e) -> (Vec n a, Vec n b, Vec n c, Vec n d, Vec n e)
unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => 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)
elem :: (Unbox a, Eq a) => a -> Vec n a -> Bool
notElem :: (Unbox a, Eq a) => a -> Vec n a -> Bool
find :: (Unbox a, Eq a) => (a -> Bool) -> Vec n a -> Maybe a
findIndex :: (Unbox a) => (a -> Bool) -> Vec n a -> Maybe (Fin n)
findIndices :: (Unbox a) => (a -> Bool) -> Vec n a -> Vec m (Fin n)
elemIndex :: (Unbox a, Eq a) => a -> Vec n a -> Maybe (Fin n)
elemIndices :: (Unbox a, Eq a) => a -> Vec n a -> Vec m (Fin n)
foldl :: (Unbox b) => (a -> b -> a) -> a -> Vec n b -> a
foldl1 :: (Unbox a) => (a -> a -> a) -> Vec (S n) a -> a
foldl' :: (Unbox b) => (a -> b -> a) -> a -> Vec n b -> a
foldl1' :: (Unbox a) => (a -> a -> a) -> Vec (S n) a -> a
foldr :: (Unbox a) => (a -> b -> b) -> b -> Vec n a -> b
foldr1 :: (Unbox a) => (a -> a -> a) -> Vec (S n) a -> a
foldr' :: (Unbox a) => (a -> b -> b) -> b -> Vec n a -> b
foldr1' :: (Unbox a) => (a -> a -> a) -> Vec (S n) a -> a
ifoldl :: (Unbox b) => (a -> Fin n -> b -> a) -> a -> Vec n b -> a
ifoldl' :: (Unbox b) => (a -> Fin n -> b -> a) -> a -> Vec n b -> a
ifoldr :: (Unbox a) => (Fin n -> a -> b -> b) -> b -> Vec n a -> b
ifoldr' :: (Unbox a) => (Fin n -> a -> b -> b) -> b -> Vec n a -> b
all :: (Unbox a) => (a -> Bool) -> Vec n a -> Bool
any :: (Unbox a) => (a -> Bool) -> Vec n a -> Bool
and :: Vec n Bool -> Bool
or :: Vec n Bool -> Bool
sum :: (Unbox a, Num a) => Vec n a -> a
product :: (Unbox a, Num a) => Vec n a -> a
minimum :: (Unbox a, Ord a) => Vec (S n) a -> a
minimumBy :: (Unbox a) => (a -> a -> Ordering) -> Vec (S n) a -> a
minIndex :: (Unbox a, Ord a) => Vec (S n) a -> Fin (S n)
minIndexBy :: (Unbox a) => (a -> a -> Ordering) -> Vec (S n) a -> Fin (S n)
maximum :: (Unbox a, Ord a) => Vec (S n) a -> a
maximumBy :: (Unbox a) => (a -> a -> Ordering) -> Vec (S n) a -> a
maxIndex :: (Unbox a, Ord a) => Vec (S n) a -> Fin (S n)
maxIndexBy :: (Unbox a) => (a -> a -> Ordering) -> Vec (S n) a -> Fin (S n)
unfoldr :: (Unbox a) => (b -> Maybe (a, b)) -> b -> (forall n. Vec n a -> r) -> r
enumFromN :: (Unbox a, Num a) => a -> Nat n -> Vec n a
enumFromStepN :: (Unbox a, Num a) => a -> a -> Nat n -> Vec n a
toList :: (Unbox a) => Vec n a -> [a]
fromList :: (Unbox a) => [a] -> (forall n. Vec n a -> r) -> r
stream :: (Unbox a) => Vec n a -> Stream a
unstream :: (Unbox a) => Stream a -> (forall n. Vec n a -> r) -> r
streamR :: (Unbox a) => Vec n a -> Stream a
unstreamR :: (Unbox a) => Stream a -> (forall n. Vec n a -> r) -> r
new :: (Unbox a) => New a -> (forall n. Vec n a -> r) -> r
allFin :: Nat n -> Vec n (Fin n)
instance (Eq a, Unbox a) => Eq (Vec n a)
instance (Ord a, Unbox a) => Ord (Vec n a)
instance (Show a, Unbox a) => Show (Vec n a)
instance (Reify n, Floating a, Unbox a) => Floating (Vec n a)
instance (Reify n, Fractional a, Unbox a) => Fractional (Vec n a)
instance (Reify n, Num a, Unbox a) => Num (Vec n a)
instance (Reify n, Bounded a, Unbox a) => Bounded (Vec n a)
instance (Reify n, Monoid a, Unbox a) => Monoid (Vec n a)
instance (Unbox a, Reify n) => Vector Vector (Vec n a)
instance (Reify n, Unbox a) => MVector MVector (Vec n a)
instance (Unbox a, Reify n) => Unbox (Vec n a)

module Data.Vector.Storable.Static
newtype Vec n a
Vec :: Vec n Vector a -> Vec n a
unVec :: Vec n a -> Vec n Vector a
length :: (Storable a) => Vec n a -> Nat n
empty :: (Storable a) => Vec Z a
singleton :: (Storable a) => a -> Vec (S Z) a
cons :: (Storable a) => a -> Vec n a -> Vec (S n) a
snoc :: (Storable a) => Vec n a -> a -> Vec (S n) a
replicate :: (Storable a) => Nat n -> a -> Vec n a
generate :: (Storable a) => Nat n -> (Fin n -> a) -> Vec n a
(++) :: (Storable a) => Vec m a -> Vec n a -> Vec (m :+: n) a
copy :: (Storable a) => Vec n a -> Vec n a
(!) :: (Storable a) => Vec n a -> Fin n -> a
head :: (Storable a) => Vec (S n) a -> a
last :: (Storable a) => Vec (S n) a -> a
init :: (Storable a) => Vec (S n) a -> Vec n a
tail :: (Storable a) => Vec (S n) a -> Vec n a
backpermute :: (Storable a) => Vec m a -> Vec n (Fin m) -> Vec n a
reverse :: (Storable a) => Vec n a -> Vec n a
map :: (Storable a, Storable b) => (a -> b) -> Vec n a -> Vec n b
imap :: (Storable a, Storable b) => (Fin n -> a -> b) -> Vec n a -> Vec n b
concatMap :: (Storable a, Storable b) => (a -> Vec n b) -> Vec m a -> Vec (m :*: n) b
zipWith :: (Storable a, Storable b, Storable c) => (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
zipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n d
zipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e
zipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f) => (a -> b -> c -> d -> e -> f) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f
zipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable g) => (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 g
izipWith :: (Storable a, Storable b, Storable c) => (Fin n -> a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
izipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (Fin n -> a -> b -> c -> d) -> Vec n a -> Vec n b -> Vec n c -> Vec n d
izipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (Fin n -> a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e
izipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f) => (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 f
izipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable g) => (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 g
elem :: (Storable a, Eq a) => a -> Vec n a -> Bool
notElem :: (Storable a, Eq a) => a -> Vec n a -> Bool
find :: (Storable a, Eq a) => (a -> Bool) -> Vec n a -> Maybe a
findIndex :: (Storable a) => (a -> Bool) -> Vec n a -> Maybe (Fin n)
elemIndex :: (Storable a, Eq a) => a -> Vec n a -> Maybe (Fin n)
foldl :: (Storable b) => (a -> b -> a) -> a -> Vec n b -> a
foldl1 :: (Storable a) => (a -> a -> a) -> Vec (S n) a -> a
foldl' :: (Storable b) => (a -> b -> a) -> a -> Vec n b -> a
foldl1' :: (Storable a) => (a -> a -> a) -> Vec (S n) a -> a
foldr :: (Storable a) => (a -> b -> b) -> b -> Vec n a -> b
foldr1 :: (Storable a) => (a -> a -> a) -> Vec (S n) a -> a
foldr' :: (Storable a) => (a -> b -> b) -> b -> Vec n a -> b
foldr1' :: (Storable a) => (a -> a -> a) -> Vec (S n) a -> a
ifoldl :: (Storable b) => (a -> Fin n -> b -> a) -> a -> Vec n b -> a
ifoldl' :: (Storable b) => (a -> Fin n -> b -> a) -> a -> Vec n b -> a
ifoldr :: (Storable a) => (Fin n -> a -> b -> b) -> b -> Vec n a -> b
ifoldr' :: (Storable a) => (Fin n -> a -> b -> b) -> b -> Vec n a -> b
all :: (Storable a) => (a -> Bool) -> Vec n a -> Bool
any :: (Storable a) => (a -> Bool) -> Vec n a -> Bool
and :: Vec n Bool -> Bool
or :: Vec n Bool -> Bool
sum :: (Storable a, Num a) => Vec n a -> a
product :: (Storable a, Num a) => Vec n a -> a
minimum :: (Storable a, Ord a) => Vec (S n) a -> a
minimumBy :: (Storable a) => (a -> a -> Ordering) -> Vec (S n) a -> a
minIndex :: (Storable a, Ord a) => Vec (S n) a -> Fin (S n)
minIndexBy :: (Storable a) => (a -> a -> Ordering) -> Vec (S n) a -> Fin (S n)
maximum :: (Storable a, Ord a) => Vec (S n) a -> a
maximumBy :: (Storable a) => (a -> a -> Ordering) -> Vec (S n) a -> a
maxIndex :: (Storable a, Ord a) => Vec (S n) a -> Fin (S n)
maxIndexBy :: (Storable a) => (a -> a -> Ordering) -> Vec (S n) a -> Fin (S n)
unfoldr :: (Storable a) => (b -> Maybe (a, b)) -> b -> (forall n. Vec n a -> r) -> r
enumFromN :: (Storable a, Num a) => a -> Nat n -> Vec n a
enumFromStepN :: (Storable a, Num a) => a -> a -> Nat n -> Vec n a
toList :: (Storable a) => Vec n a -> [a]
fromList :: (Storable a) => [a] -> (forall n. Vec n a -> r) -> r
stream :: (Storable a) => Vec n a -> Stream a
unstream :: (Storable a) => Stream a -> (forall n. Vec n a -> r) -> r
streamR :: (Storable a) => Vec n a -> Stream a
unstreamR :: (Storable a) => Stream a -> (forall n. Vec n a -> r) -> r
new :: (Storable a) => New a -> (forall n. Vec n a -> r) -> r