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


-- | Size tagged vectors
--   
--   Please see README.md
@package vector-sized
@version 1.5.0

module Data.Vector.Generic.Mutable.Sized.Internal

-- | A wrapper to tag mutable vectors with a type level length.
--   
--   Be careful when using the constructor here to not construct sized
--   vectors which have a different length than that specified in the type
--   parameter!
newtype MVector v (n :: Nat) s a
MVector :: v s a -> MVector v (n :: Nat) s a
instance Control.DeepSeq.NFData (v s a) => Control.DeepSeq.NFData (Data.Vector.Generic.Mutable.Sized.Internal.MVector v n s a)
instance Foreign.Storable.Storable (v s a) => Foreign.Storable.Storable (Data.Vector.Generic.Mutable.Sized.Internal.MVector v n s a)
instance (GHC.TypeNats.KnownNat n, Data.Typeable.Internal.Typeable v, Data.Typeable.Internal.Typeable s, Data.Typeable.Internal.Typeable a, Data.Data.Data (v s a)) => Data.Data.Data (Data.Vector.Generic.Mutable.Sized.Internal.MVector v n s a)


-- | This module reexports the functionality in <a>Mutable</a> which maps
--   well to explicitly sized vectors.
--   
--   Functions returning a vector determine the size from the type context
--   unless they have a <tt>'</tt> suffix in which case they take an
--   explicit <a>Proxy</a> argument.
--   
--   Functions where the resultant vector size is not known until runtime
--   are not exported.
module Data.Vector.Generic.Mutable.Sized

-- | A wrapper to tag mutable vectors with a type level length.
--   
--   Be careful when using the constructor here to not construct sized
--   vectors which have a different length than that specified in the type
--   parameter!
data MVector v (n :: Nat) s a

-- | <i>O(1)</i> Yield the length of the mutable vector as an <a>Int</a>.
length :: forall v n s a. KnownNat n => MVector v n s a -> Int

-- | <i>O(1)</i> Yield the length of the mutable vector as a <a>Proxy</a>.
length' :: forall v n s a. () => MVector v n s a -> Proxy n

-- | <i>O(1)</i> Check whether the mutable vector is empty.
null :: forall v n s a. KnownNat n => MVector v n s a -> Bool

-- | <i>O(1)</i> Yield a slice of the mutable vector without copying it
--   with an inferred length argument.
slice :: forall v i n k s a p. (KnownNat i, KnownNat n, MVector v a) => p i -> MVector v ((i + n) + k) s a -> MVector v n s a

-- | <i>O(1)</i> Yield a slice of the mutable vector without copying it
--   with an explicit length argument.
slice' :: forall v i n k s a p. (KnownNat i, KnownNat n, MVector v a) => p i -> p n -> MVector v ((i + n) + k) s a -> MVector v n s a

-- | <i>O(1)</i> Yield all but the last element of a non-empty mutable
--   vector without copying.
init :: forall v n s a. MVector v a => MVector v (n + 1) s a -> MVector v n s a

-- | <i>O(1)</i> Yield all but the first element of a non-empty mutable
--   vector without copying.
tail :: forall v n s a. MVector v a => MVector v (1 + n) s a -> MVector v n s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is inferred from the type.
take :: forall v n k s a. (KnownNat n, MVector v a) => MVector v (n + k) s a -> MVector v n s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is given explicitly as a <a>Proxy</a> argument.
take' :: forall v n k s a p. (KnownNat n, MVector v a) => p n -> MVector v (n + k) s a -> MVector v n s a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is inferred from the type.
drop :: forall v n k s a. (KnownNat n, MVector v a) => MVector v (n + k) s a -> MVector v k s a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is given explicitly as a <a>Proxy</a> argument.
drop' :: forall v n k s a p. (KnownNat n, MVector v a) => p n -> MVector v (n + k) s a -> MVector v k s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The lengths of the resulting vectors are inferred
--   from the type.
splitAt :: forall v n m s a. (KnownNat n, MVector v a) => MVector v (n + m) s a -> (MVector v n s a, MVector v m s a)

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The length of the first resulting vector is passed
--   explicitly as a <a>Proxy</a> argument.
splitAt' :: forall v n m s a p. (KnownNat n, MVector v a) => p n -> MVector v (n + m) s a -> (MVector v n s a, MVector v m s a)

-- | <i>O(1)</i> Check whether two vectors overlap.
overlaps :: forall v n k s a. MVector v a => MVector v n s a -> MVector v k s a -> Bool

-- | Create a mutable vector where the length is inferred from the type.
new :: forall v n m a. (KnownNat n, PrimMonad m, MVector v a) => m (MVector v n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type.
--   The memory is not initialized.
unsafeNew :: forall v n m a. (KnownNat n, PrimMonad m, MVector v a) => m (MVector v n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type and
--   fill it with an initial value.
replicate :: forall v n m a. (KnownNat n, PrimMonad m, MVector v a) => a -> m (MVector v n (PrimState m) a)

-- | Create a mutable vector where the length is given explicitly as a
--   <a>Proxy</a> argument and fill it with an initial value.
replicate' :: forall v n m a p. (KnownNat n, PrimMonad m, MVector v a) => p n -> a -> m (MVector v n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type and
--   fill it with values produced by repeatedly executing the monadic
--   action.
replicateM :: forall v n m a. (KnownNat n, PrimMonad m, MVector v a) => m a -> m (MVector v n (PrimState m) a)

-- | Create a mutable vector where the length is given explicitly as a
--   <a>Proxy</a> argument and fill it with values produced by repeatedly
--   executing the monadic action.
replicateM' :: forall v n m a p. (KnownNat n, PrimMonad m, MVector v a) => p n -> m a -> m (MVector v n (PrimState m) a)

-- | Create a copy of a mutable vector.
clone :: forall v n m a. (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> m (MVector v n (PrimState m) a)

-- | Grow a mutable vector by an amount given explicitly as a <a>Proxy</a>
--   argument.
grow :: forall v n k m a p. (KnownNat k, PrimMonad m, MVector v a) => p k -> MVector v n (PrimState m) a -> m (MVector v (n + k) (PrimState m) a)

-- | Grow a mutable vector (from the front) by an amount given explicitly
--   as a <a>Proxy</a> argument.
growFront :: forall v n k m a p. (KnownNat k, PrimMonad m, MVector v a) => p k -> MVector v n (PrimState m) a -> m (MVector v (n + k) (PrimState m) a)

-- | Reset all elements of the vector to some undefined value, clearing all
--   references to external objects.
clear :: (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> m ()

-- | <i>O(1)</i> Yield the element at a given type-safe position using
--   <a>Finite</a>.
read :: forall v n m a. (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> Finite n -> m a

-- | <i>O(1)</i> Yield the element at a given type-safe position using
--   <a>Proxy</a>.
read' :: forall v n k a m p. (KnownNat k, PrimMonad m, MVector v a) => MVector v ((n + k) + 1) (PrimState m) a -> p k -> m a

-- | <i>O(1)</i> Replace the element at a given type-safe position using
--   <a>Finite</a>.
write :: forall v n m a. (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> Finite n -> a -> m ()

-- | <i>O(1)</i> Replace the element at a given type-safe position using
--   <a>Proxy</a>.
write' :: forall v n k a m p. (KnownNat k, PrimMonad m, MVector v a) => MVector v ((n + k) + 1) (PrimState m) a -> p k -> a -> m ()

-- | <i>O(1)</i> Modify the element at a given type-safe position using
--   <a>Finite</a>.
modify :: forall v n m a. (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> (a -> a) -> Finite n -> m ()

-- | <i>O(1)</i> Modify the element at a given type-safe position using
--   <a>Proxy</a>.
modify' :: forall v n k a m p. (KnownNat k, PrimMonad m, MVector v a) => MVector v ((n + k) + 1) (PrimState m) a -> (a -> a) -> p k -> m ()

-- | <i>O(1)</i> Swap the elements at given type-safe positions using
--   <a>Finite</a>s.
swap :: forall v n m a. (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> Finite n -> Finite n -> m ()

-- | <i>O(1)</i> Replace the element at a given type-safe position and
--   return the old element, using <a>Finite</a>.
exchange :: forall v n m a. (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> Finite n -> a -> m a

-- | <i>O(1)</i> Replace the element at a given type-safe position and
--   return the old element, using <a>Finite</a>.
exchange' :: forall v n k a m p. (KnownNat k, PrimMonad m, MVector v a) => MVector v ((n + k) + 1) (PrimState m) a -> p k -> a -> m a

-- | <i>O(1)</i> Yield the element at a given <a>Int</a> position without
--   bounds checking.
unsafeRead :: forall v n a m. (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> Int -> m a

-- | <i>O(1)</i> Replace the element at a given <a>Int</a> position without
--   bounds checking.
unsafeWrite :: forall v n m a. (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> Int -> a -> m ()

-- | <i>O(1)</i> Modify the element at a given <a>Int</a> position without
--   bounds checking.
unsafeModify :: forall v n m a. (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> (a -> a) -> Int -> m ()

-- | <i>O(1)</i> Swap the elements at given <a>Int</a> positions without
--   bounds checking.
unsafeSwap :: forall v n m a. (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> Int -> Int -> m ()

-- | <i>O(1)</i> Replace the element at a given <a>Int</a> position and
--   return the old element. No bounds checks are performed.
unsafeExchange :: forall v n m a. (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> Int -> a -> m a

-- | Compute the next permutation (in lexicographic order) of a given
--   vector in-place. Returns <a>False</a> when the input is the last
--   permutation.
nextPermutation :: forall v n e m. (Ord e, PrimMonad m, MVector v e) => MVector v n (PrimState m) e -> m Bool

-- | Set all elements of the vector to the given value.
set :: (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> a -> m ()

-- | Copy a vector. The two vectors may not overlap.
copy :: (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> MVector v n (PrimState m) a -> m ()

-- | Move the contents of a vector. If the two vectors do not overlap, this
--   is equivalent to <a>copy</a>. Otherwise, the copying is performed as
--   if the source vector were copied to a temporary vector and then the
--   temporary vector was copied to the target vector.
move :: (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> MVector v n (PrimState m) a -> m ()

-- | Copy a vector. The two vectors may not overlap. This is not checked.
unsafeCopy :: (PrimMonad m, MVector v a) => MVector v n (PrimState m) a -> MVector v n (PrimState m) a -> m ()

-- | Convert a <a>MVector</a> into a <a>MVector</a> if it has the correct
--   size, otherwise return Nothing.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
toSized :: forall v n s a. (MVector v a, KnownNat n) => v s a -> Maybe (MVector v n s a)

-- | Takes a <a>MVector</a> and returns a continuation providing a
--   <a>MVector</a> with a size parameter <tt>n</tt> that is determined at
--   runtime based on the length of the input vector.
--   
--   Essentially converts a <a>MVector</a> into a <a>MVector</a> with the
--   correct size parameter <tt>n</tt>.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
withSized :: forall v s a r. MVector v a => v s a -> (forall n. KnownNat n => MVector v n s a -> r) -> r

-- | Convert a <a>MVector</a> into a <a>MVector</a>.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
fromSized :: MVector v n s a -> v s a

module Data.Vector.Generic.Sized.Internal

-- | A wrapper to tag vectors with a type level length.
--   
--   Be careful when using the constructor here to not construct sized
--   vectors which have a different length than that specified in the type
--   parameter!
newtype Vector v (n :: Nat) a
Vector :: v a -> Vector v (n :: Nat) a
instance (GHC.TypeNats.KnownNat n, Data.Typeable.Internal.Typeable v, Data.Typeable.Internal.Typeable a, Data.Data.Data (v a)) => Data.Data.Data (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance Data.Functor.Classes.Ord1 v => Data.Functor.Classes.Ord1 (Data.Vector.Generic.Sized.Internal.Vector v n)
instance Data.Functor.Classes.Eq1 v => Data.Functor.Classes.Eq1 (Data.Vector.Generic.Sized.Internal.Vector v n)
instance Data.Functor.Classes.Show1 v => Data.Functor.Classes.Show1 (Data.Vector.Generic.Sized.Internal.Vector v n)
instance Control.DeepSeq.NFData (v a) => Control.DeepSeq.NFData (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance Data.Traversable.Traversable v => Data.Traversable.Traversable (Data.Vector.Generic.Sized.Internal.Vector v n)
instance Data.Foldable.Foldable v => Data.Foldable.Foldable (Data.Vector.Generic.Sized.Internal.Vector v n)
instance GHC.Base.Functor v => GHC.Base.Functor (Data.Vector.Generic.Sized.Internal.Vector v n)
instance GHC.Classes.Ord (v a) => GHC.Classes.Ord (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance GHC.Classes.Eq (v a) => GHC.Classes.Eq (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance GHC.Show.Show (v a) => GHC.Show.Show (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance (GHC.Ix.Ix a, GHC.Classes.Ord (v a), Data.Vector.Generic.Base.Vector v a) => GHC.Ix.Ix (Data.Vector.Generic.Sized.Internal.Vector v n a)


-- | This module reexports the functionality in <a>Generic</a> which maps
--   well to explicity sized vectors.
--   
--   Functions returning a vector determine the size from the type context
--   unless they have a <tt>'</tt> suffix in which case they take an
--   explicit <a>Proxy</a> argument.
--   
--   Functions where the resultant vector size is not know until compile
--   time are not exported.
module Data.Vector.Generic.Sized

-- | A wrapper to tag vectors with a type level length.
--   
--   Be careful when using the constructor here to not construct sized
--   vectors which have a different length than that specified in the type
--   parameter!
data Vector v (n :: Nat) a

-- | Pattern synonym that lets you treat an unsized vector as if it
--   "contained" a sized vector. If you pattern match on an unsized vector,
--   its contents will be the <i>sized</i> vector counterpart.
--   
--   <pre>
--   testFunc :: Unsized.Vector Int -&gt; Int
--   testFunc (<a>SomeSized</a> v) =
--       <a>sum</a> (<a>zipWith</a> (+) v (<a>replicate</a> 1))
--           -- ^ here, v is `Sized.Vector n Int`, and we have
--                       `<a>KnownNat</a> n`
--   </pre>
--   
--   The <tt>n</tt> type variable will be properly instantiated to whatever
--   the length of the vector is, and you will also have a
--   <tt><a>KnownNat</a> n</tt> instance available. You can get <tt>n</tt>
--   in scope by turning on ScopedTypeVariables and matching on
--   <tt><a>SomeSized</a> (v :: Sized.Vector n Int)</tt>.
--   
--   Without this, you would otherwise have to use <a>withSized</a> to do
--   the same thing:
--   
--   <pre>
--   testFunc :: Unsized.Vector Int -&gt; Int
--   testFunc u = <a>withSized</a> u $ \v -&gt;
--       <a>sum</a> (<a>zipWith</a> (+) v (<a>replicate</a> 1))
--   </pre>
--   
--   Remember that the type of final result of your function (the
--   <tt>Int</tt>, here) must <i>not</i> depend on <tt>n</tt>. However, the
--   types of the intermediate values are allowed to depend on <tt>n</tt>.
--   
--   This is <i>especially</i> useful in do blocks, where you can pattern
--   match on the unsized results of actions, to use the sized vector in
--   the rest of the do block. You also get a <tt><a>KnownNat</a> n</tt>
--   constraint for the remainder of the do block.
--   
--   <pre>
--   -- If you had:
--   getAVector :: IO (Unsized.Vector Int)
--   
--   main :: IO ()
--   main = do
--       SomeSized v &lt;- getAVector -- v is `Sized.Vector n Int`
--       print v
--   
--       -- alternatively, get n in scope
--       SomeSized (v2 :: Sized.Vector n Int) &lt;- getAVector
--       print v2
--   </pre>
--   
--   Remember that the final type of the result of the do block
--   (<tt>()</tt>, here) must not depend on <tt>n</tt>. However, the
--   
--   Also useful in ghci, where you can pattern match to get sized vectors
--   from unsized vectors.
--   
--   <pre>
--   ghci&gt; SomeSized v &lt;- pure (myUnsizedVector :: Unsized.Vector Int)
--                -- ^ v is `Sized.Vector n Int`
--   </pre>
--   
--   This enables interactive exploration with sized vectors in ghci, and
--   is useful for using with other libraries and functions that expect
--   sized vectors in an interactive setting.
--   
--   (Note that as of GHC 8.6, you cannot get the <tt>n</tt> in scope in
--   your ghci session using ScopedTypeVariables, like you can with do
--   blocks)
--   
--   You can also use this as a constructor, to take a sized vector and
--   "hide" the size, to produce an unsized vector:
--   
--   <pre>
--   SomeSized :: Sized.Vector n a -&gt; Unsized.Vector a
--   </pre>
--   
--   Note that due to quirks in GHC pattern synonym completeness checking,
--   you will get incomplete pattern matches if you use this
--   polymorphically over different vector types, or you use any vector
--   type other than the three supported by this library (normal, storable,
--   unboxed).
pattern SomeSized :: Vector v a => forall n. KnownNat n => Vector v n a -> v a

-- | A wrapper to tag mutable vectors with a type level length.
--   
--   Be careful when using the constructor here to not construct sized
--   vectors which have a different length than that specified in the type
--   parameter!
data MVector v (n :: Nat) s a

-- | <i>O(1)</i> Yield the length of the vector as an <a>Int</a>. This is
--   more like <a>natVal</a> than <a>length</a>, extracting the value from
--   the <a>KnownNat</a> instance and not looking at the vector itself.
length :: forall v n a. KnownNat n => Vector v n a -> Int

-- | <i>O(1)</i> Yield the length of the vector as a <a>Proxy</a>. This
--   function doesn't <i>do</i> anything; it merely allows the size
--   parameter of the vector to be passed around as a <a>Proxy</a>.
length' :: forall v n a. Vector v n a -> Proxy n

-- | <i>O(1)</i> Reveal a <a>KnownNat</a> instance for a vector's length,
--   determined at runtime.
knownLength :: forall v n a r. Vector v a => Vector v n a -> (KnownNat n => r) -> r

-- | <i>O(1)</i> Reveal a <a>KnownNat</a> instance and <a>Proxy</a> for a
--   vector's length, determined at runtime.
knownLength' :: forall v n a r. Vector v a => Vector v n a -> (KnownNat n => Proxy n -> r) -> r

-- | <i>O(1)</i> Safe indexing using a <a>Finite</a>.
index :: forall v n a. Vector v a => Vector v n a -> Finite n -> a

-- | <i>O(1)</i> Safe indexing using a <a>Proxy</a>.
index' :: forall v n m a p. (KnownNat n, Vector v a) => Vector v ((n + m) + 1) a -> p n -> a

-- | <i>O(1)</i> Indexing using an <a>Int</a> without bounds checking.
unsafeIndex :: forall v n a. Vector v a => Vector v n a -> Int -> a

-- | <i>O(1)</i> Yield the first element of a non-empty vector.
head :: forall v n a. Vector v a => Vector v (1 + n) a -> a

-- | <i>O(1)</i> Yield the last element of a non-empty vector.
last :: forall v n a. Vector v a => Vector v (n + 1) a -> a

-- | <i>O(1)</i> Safe indexing in a monad.
--   
--   The monad allows operations to be strict in the vector when necessary.
--   Suppose vector copying is implemented like this:
--   
--   <pre>
--   copy mv v = ... write mv i (v ! i) ...
--   </pre>
--   
--   For lazy vectors, <tt>v ! i</tt> would not be evaluated, which means
--   that <tt>mv</tt> would unnecessarily retain a reference to <tt>v</tt>
--   in each element when written.
--   
--   With <a>indexM</a>, copying can be implemented like this instead:
--   
--   <pre>
--   copy mv v = ... do
--                    x &lt;- indexM v i
--                    write mv i x
--   </pre>
--   
--   Here, no references to <tt>v</tt> are retained, because indexing (but
--   <i>not</i> the elements) are evaluated eagerly.
indexM :: forall v n a m. (Vector v a, Monad m) => Vector v n a -> Finite n -> m a

-- | <i>O(1)</i> Safe indexing in a monad using a <a>Proxy</a>. See the
--   documentation for <a>indexM</a> for an explanation of why this is
--   useful.
indexM' :: forall v n k a m p. (KnownNat n, Vector v a, Monad m) => Vector v (n + k) a -> p n -> m a

-- | <i>O(1)</i> Indexing using an Int without bounds checking. See the
--   documentation for <a>indexM</a> for an explanation of why this is
--   useful.
unsafeIndexM :: forall v n a m. (Vector v a, Monad m) => Vector v n a -> Int -> m a

-- | <i>O(1)</i> Yield the first element of a non-empty vector in a monad.
--   See the documentation for <a>indexM</a> for an explanation of why this
--   is useful.
headM :: forall v n a m. (Vector v a, Monad m) => Vector v (1 + n) a -> m a

-- | <i>O(1)</i> Yield the last element of a non-empty vector in a monad.
--   See the documentation for <a>indexM</a> for an explanation of why this
--   is useful.
lastM :: forall v n a m. (Vector v a, Monad m) => Vector v (n + 1) a -> m a

-- | <i>O(1)</i> Yield a slice of the vector without copying it with an
--   inferred length argument.
slice :: forall v i n m a p. (KnownNat i, KnownNat n, Vector v a) => p i -> Vector v ((i + n) + m) a -> Vector v n a

-- | <i>O(1)</i> Yield a slice of the vector without copying it with an
--   explicit length argument.
slice' :: forall v i n m a p. (KnownNat i, KnownNat n, Vector v a) => p i -> p n -> Vector v ((i + n) + m) a -> Vector v n a

-- | <i>O(1)</i> Yield all but the last element of a non-empty vector
--   without copying.
init :: forall v n a. Vector v a => Vector v (n + 1) a -> Vector v n a

-- | <i>O(1)</i> Yield all but the first element of a non-empty vector
--   without copying.
tail :: forall v n a. Vector v a => Vector v (1 + n) a -> Vector v n a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is inferred from the type.
take :: forall v n m a. (KnownNat n, Vector v a) => Vector v (n + m) a -> Vector v n a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is given explicitly as a <a>Proxy</a> argument.
take' :: forall v n m a p. (KnownNat n, Vector v a) => p n -> Vector v (n + m) a -> Vector v n a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is inferred from the type.
drop :: forall v n m a. (KnownNat n, Vector v a) => Vector v (n + m) a -> Vector v m a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is givel explicitly as a <a>Proxy</a> argument.
drop' :: forall v n m a p. (KnownNat n, Vector v a) => p n -> Vector v (n + m) a -> Vector v m a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The lengths of the resulting vectors are inferred
--   from the type.
splitAt :: forall v n m a. (KnownNat n, Vector v a) => Vector v (n + m) a -> (Vector v n a, Vector v m a)

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The length of the first resulting vector is passed
--   explicitly as a <a>Proxy</a> argument.
splitAt' :: forall v n m a p. (KnownNat n, Vector v a) => p n -> Vector v (n + m) a -> (Vector v n a, Vector v m a)

-- | <i>O(1)</i> Empty vector.
empty :: forall v a. Vector v a => Vector v 0 a

-- | <i>O(1)</i> Vector with exactly one element.
singleton :: forall v a. Vector v a => a -> Vector v 1 a

-- | <i>O(n)</i> Construct a vector in a type-safe manner. <tt> fromTuple
--   (1,2) :: Vector v 2 Int fromTuple ("hey", "what's", "going", "on") ::
--   Vector v 4 String </tt>
fromTuple :: forall v a input length. (Vector v a, IndexedListLiterals input length a, KnownNat length) => input -> Vector v length a

-- | <i>O(n)</i> Construct a vector with the same element in each position
--   where the length is inferred from the type.
replicate :: forall v n a. (KnownNat n, Vector v a) => a -> Vector v n a

-- | <i>O(n)</i> Construct a vector with the same element in each position
--   where the length is given explicitly as a <a>Proxy</a> argument.
replicate' :: forall v n a p. (KnownNat n, Vector v a) => p n -> a -> Vector v n a

-- | <i>O(n)</i> Construct a vector of the given length by applying the
--   function to each index where the length is inferred from the type.
generate :: forall v n a. (KnownNat n, Vector v a) => (Finite n -> a) -> Vector v n a

-- | <i>O(n)</i> Construct a vector of the given length by applying the
--   function to each index where the length is given explicitly as a
--   <a>Proxy</a> argument.
generate' :: forall v n a p. (KnownNat n, Vector v a) => p n -> (Finite n -> a) -> Vector v n a

-- | <i>O(n)</i> Apply the function <tt>n</tt> times to a value. Zeroth
--   element is the original value. The length is inferred from the type.
iterateN :: forall v n a. (KnownNat n, Vector v a) => (a -> a) -> a -> Vector v n a

-- | <i>O(n)</i> Apply the function <tt>n</tt> times to a value. Zeroth
--   element is the original value. The length is given explicitly as a
--   <a>Proxy</a> argument.
iterateN' :: forall v n a p. (KnownNat n, Vector v a) => p n -> (a -> a) -> a -> Vector v n a

-- | <i>O(n)</i> Execute the monadic action <tt>n</tt> times and store the
--   results in a vector where <tt>n</tt> is inferred from the type.
replicateM :: forall v n m a. (KnownNat n, Vector v a, Monad m) => m a -> m (Vector v n a)

-- | <i>O(n)</i> Execute the monadic action <tt>n</tt> times and store the
--   results in a vector where <tt>n</tt> is given explicitly as a
--   <a>Proxy</a> argument.
replicateM' :: forall v n m a p. (KnownNat n, Vector v a, Monad m) => p n -> m a -> m (Vector v n a)

-- | <i>O(n)</i> Construct a vector of length <tt>n</tt> by applying the
--   monadic action to each index where <tt>n</tt> is inferred from the
--   type.
generateM :: forall v n m a. (KnownNat n, Vector v a, Monad m) => (Finite n -> m a) -> m (Vector v n a)

-- | <i>O(n)</i> Construct a vector of length <tt>n</tt> by applying the
--   monadic action to each index where <tt>n</tt> is given explicitly as a
--   <a>Proxy</a> argument.
generateM' :: forall v n m a p. (KnownNat n, Vector v a, Monad m) => p n -> (Finite n -> m a) -> m (Vector v n a)

-- | <i>O(n)</i> Construct a vector with exactly <tt>n</tt> elements by
--   repeatedly applying the generator function to the a seed. The length
--   is inferred from the type.
unfoldrN :: forall v n a b. (KnownNat n, Vector v a) => (b -> (a, b)) -> b -> Vector v n a

-- | <i>O(n)</i> Construct a vector with exactly <tt>n</tt> elements by
--   repeatedly applying the generator function to the a seed. The length
--   is given explicitly as a <a>Proxy</a> argument.
unfoldrN' :: forall v n a b p. (KnownNat n, Vector v a) => p n -> (b -> (a, b)) -> b -> Vector v n a

-- | <i>O(n)</i> Yield a vector of length <tt>n</tt> containing the values
--   <tt>x</tt>, <tt>x+1</tt>, ... <tt>x + (n - 1)</tt>. The length is
--   inferred from the type.
enumFromN :: forall v n a. (KnownNat n, Vector v a, Num a) => a -> Vector v n a

-- | <i>O(n)</i> Yield a vector of length <tt>n</tt> containing the values
--   <tt>x</tt>, <tt>x+1</tt>, ..., <tt>x + (n - 1)</tt> The length is
--   given explicitly as a <a>Proxy</a> argument.
enumFromN' :: forall v n a p. (KnownNat n, Vector v a, Num a) => a -> p n -> Vector v n a

-- | <i>O(n)</i> Yield a vector of the given length containing the values
--   <tt>x</tt>, <tt>x+y</tt>, <tt>x+2y</tt>, ... <tt>x + (n - 1)y</tt>.
--   The length is inferred from the type.
enumFromStepN :: forall v n a. (KnownNat n, Vector v a, Num a) => a -> a -> Vector v n a

-- | <i>O(n)</i> Yield a vector of the given length containing the values
--   <tt>x</tt>, <tt>x+y</tt>, <tt>x+2y</tt>, ..., <tt>x + (n - 1)y</tt>.
--   The length is given explicitly as a <a>Proxy</a> argument.
enumFromStepN' :: forall v n a p. (KnownNat n, Vector v a, Num a) => a -> a -> p n -> Vector v n a

-- | <i>O(n)</i> Prepend an element.
cons :: forall v n a. Vector v a => a -> Vector v n a -> Vector v (1 + n) a

-- | <i>O(n)</i> Append an element.
snoc :: forall v n a. Vector v a => Vector v n a -> a -> Vector v (n + 1) a

-- | <i>O(m+n)</i> Concatenate two vectors.
(++) :: forall v n m a. Vector v a => Vector v n a -> Vector v m a -> Vector v (n + m) a

-- | <i>O(n)</i> Yield the argument but force it not to retain any extra
--   memory, possibly by copying it.
--   
--   This is especially useful when dealing with slices. For example:
--   
--   <pre>
--   force (slice 0 2 &lt;huge vector&gt;)
--   </pre>
--   
--   Here, the slice retains a reference to the huge vector. Forcing it
--   creates a copy of just the elements that belong to the slice and
--   allows the huge vector to be garbage collected.
force :: Vector v a => Vector v n a -> Vector v n a

-- | <i>O(m+n)</i> For each pair <tt>(i,a)</tt> from the list, replace the
--   vector element at position <tt>i</tt> by <tt>a</tt>.
--   
--   <pre>
--   &lt;5,9,2,7&gt; // [(2,1),(0,3),(2,8)] = &lt;3,9,8,7&gt;
--   </pre>
(//) :: Vector v a => Vector v m a -> [(Finite m, a)] -> Vector v m a

-- | <i>O(m+n)</i> For each pair <tt>(i,a)</tt> from the vector of
--   index/value pairs, replace the vector element at position <tt>i</tt>
--   by <tt>a</tt>.
--   
--   <pre>
--   update &lt;5,9,2,7&gt; &lt;(2,1),(0,3),(2,8)&gt; = &lt;3,9,8,7&gt;
--   </pre>
update :: (Vector v a, Vector v (Int, a)) => Vector v m a -> Vector v n (Int, a) -> Vector v m a

-- | <i>O(m+n)</i> For each index <tt>i</tt> from the index vector and the
--   corresponding value <tt>a</tt> from the value vector, replace the
--   element of the initial vector at position <tt>i</tt> by <tt>a</tt>.
--   
--   <pre>
--   update_ &lt;5,9,2,7&gt;  &lt;2,0,2&gt; &lt;1,3,8&gt; = &lt;3,9,8,7&gt;
--   </pre>
--   
--   This function is useful for instances of <a>Vector</a> that cannot
--   store pairs. Otherwise, <a>update</a> is probably more convenient.
--   
--   <pre>
--   update_ xs is ys = <a>update</a> xs (<a>zip</a> is ys)
--   </pre>
update_ :: (Vector v a, Vector v Int) => Vector v m a -> Vector v n Int -> Vector v n a -> Vector v m a

-- | Same as (<a>//</a>) but without bounds checking.
unsafeUpd :: Vector v a => Vector v m a -> [(Int, a)] -> Vector v m a

-- | Same as <a>update</a> but without bounds checking.
unsafeUpdate :: (Vector v a, Vector v (Int, a)) => Vector v m a -> Vector v n (Int, a) -> Vector v m a

-- | Same as <a>update_</a> but without bounds checking.
unsafeUpdate_ :: (Vector v a, Vector v Int) => Vector v m a -> Vector v n Int -> Vector v n a -> Vector v m a

-- | <i>O(m+n)</i> For each pair <tt>(i,b)</tt> from the list, replace the
--   vector element <tt>a</tt> at position <tt>i</tt> by <tt>f a b</tt>.
--   
--   <pre>
--   accum (+) &lt;5,9,2&gt; [(2,4),(1,6),(0,3),(1,7)] = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
accum :: Vector v a => (a -> b -> a) -> Vector v m a -> [(Finite m, b)] -> Vector v m a

-- | <i>O(m+n)</i> For each pair <tt>(i,b)</tt> from the vector of pairs,
--   replace the vector element <tt>a</tt> at position <tt>i</tt> by <tt>f
--   a b</tt>.
--   
--   <pre>
--   accumulate (+) &lt;5,9,2&gt; &lt;(2,4),(1,6),(0,3),(1,7)&gt; = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
accumulate :: (Vector v a, Vector v (Int, b)) => (a -> b -> a) -> Vector v m a -> Vector v n (Int, b) -> Vector v m a

-- | <i>O(m+n)</i> For each index <tt>i</tt> from the index vector and the
--   corresponding value <tt>b</tt> from the the value vector, replace the
--   element of the initial vector at position <tt>i</tt> by <tt>f a
--   b</tt>.
--   
--   <pre>
--   accumulate_ (+) &lt;5,9,2&gt; &lt;2,1,0,1&gt; &lt;4,6,3,7&gt; = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
--   
--   This function is useful for instances of <a>Vector</a> that cannot
--   store pairs. Otherwise, <a>accumulate</a> is probably more convenient:
--   
--   <pre>
--   accumulate_ f as is bs = <a>accumulate</a> f as (<a>zip</a> is bs)
--   </pre>
accumulate_ :: (Vector v a, Vector v Int, Vector v b) => (a -> b -> a) -> Vector v m a -> Vector v n Int -> Vector v n b -> Vector v m a

-- | Same as <a>accum</a> but without bounds checking.
unsafeAccum :: Vector v a => (a -> b -> a) -> Vector v m a -> [(Int, b)] -> Vector v m a

-- | Same as <a>accumulate</a> but without bounds checking.
unsafeAccumulate :: (Vector v a, Vector v (Int, b)) => (a -> b -> a) -> Vector v m a -> Vector v n (Int, b) -> Vector v m a

-- | Same as <a>accumulate_</a> but without bounds checking.
unsafeAccumulate_ :: (Vector v a, Vector v Int, Vector v b) => (a -> b -> a) -> Vector v m a -> Vector v n Int -> Vector v n b -> Vector v m a

-- | <i>O(n)</i> Reverse a vector
reverse :: Vector v a => Vector v n a -> Vector v n a

-- | <i>O(n)</i> Yield the vector obtained by replacing each element
--   <tt>i</tt> of the index vector by <tt>xs<tt>!</tt>i</tt>. This is
--   equivalent to <tt><a>map</a> (xs<tt>!</tt>) is</tt> but is often much
--   more efficient.
--   
--   <pre>
--   backpermute &lt;a,b,c,d&gt; &lt;0,3,2,3,1,0&gt; = &lt;a,d,c,d,b,a&gt;
--   </pre>
backpermute :: (Vector v a, Vector v Int) => Vector v m a -> Vector v n Int -> Vector v n a

-- | Same as <a>backpermute</a> but without bounds checking.
unsafeBackpermute :: (Vector v a, Vector v Int) => Vector v m a -> Vector v n Int -> Vector v n a

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) an arbitrary
--   element by its index.
ix :: forall v n a f. (Vector v a, Functor f) => Finite n -> (a -> f a) -> Vector v n a -> f (Vector v n a)

-- | Type-safe lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) an
--   arbitrary element by its index which should be supplied via
--   TypeApplications.
ix' :: forall i v n a f. (Vector v a, Functor f, KnownNat i, KnownNat n, (i + 1) <= n) => (a -> f a) -> Vector v n a -> f (Vector v n a)

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) the first
--   element of a non-empty vector.
_head :: forall v n a f. (Vector v a, Functor f) => (a -> f a) -> Vector v (1 + n) a -> f (Vector v (1 + n) a)

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) the last element
--   of a non-empty vector.
_last :: forall v n a f. (Vector v a, Functor f) => (a -> f a) -> Vector v (n + 1) a -> f (Vector v (n + 1) a)

-- | <i>O(n)</i> Pair each element in a vector with its index.
indexed :: (Vector v a, Vector v (Int, a), Vector v (Finite n, a)) => Vector v n a -> Vector v n (Finite n, a)

-- | <i>O(n)</i> Map a function over a vector.
map :: (Vector v a, Vector v b) => (a -> b) -> Vector v n a -> Vector v n b

-- | <i>O(n)</i> Apply a function to every element of a vector and its
--   index.
imap :: (Vector v a, Vector v b) => (Finite n -> a -> b) -> Vector v n a -> Vector v n b

-- | <i>O(n*m)</i> Map a function over a vector and concatenate the
--   results. The function is required to always return a vector of the
--   same length.
concatMap :: (Vector v a, Vector v' b) => (a -> Vector v' m b) -> Vector v n a -> Vector v' (n * m) b

-- | <i>O(n)</i> Apply the monadic action to all elements of the vector,
--   yielding a vector of results.
mapM :: (Monad m, Vector v a, Vector v b) => (a -> m b) -> Vector v n a -> m (Vector v n b)

-- | <i>O(n)</i> Apply the monadic action to every element of a vector and
--   its index, yielding a vector of results.
imapM :: (Monad m, Vector v a, Vector v b) => (Finite n -> a -> m b) -> Vector v n a -> m (Vector v n b)

-- | <i>O(n)</i> Apply the monadic action to all elements of a vector and
--   ignore the results.
mapM_ :: (Monad m, Vector v a) => (a -> m b) -> Vector v n a -> m ()

-- | <i>O(n)</i> Apply the monadic action to every element of a vector and
--   its index, ignoring the results.
imapM_ :: (Monad m, Vector v a) => (Finite n -> a -> m b) -> Vector v n a -> m ()

-- | <i>O(n)</i> Apply the monadic action to all elements of the vector,
--   yielding a vector of results. Equvalent to <tt>flip <a>mapM</a></tt>.
forM :: (Monad m, Vector v a, Vector v b) => Vector v n a -> (a -> m b) -> m (Vector v n b)

-- | <i>O(n)</i> Apply the monadic action to all elements of a vector and
--   ignore the results. Equivalent to <tt>flip <a>mapM_</a></tt>.
forM_ :: (Monad m, Vector v a) => Vector v n a -> (a -> m b) -> m ()

-- | <i>O(n)</i> Zip two vectors of the same length with the given
--   function.
zipWith :: (Vector v a, Vector v b, Vector v c) => (a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c

-- | Zip three vectors with the given function.
zipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (a -> b -> c -> d) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d
zipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (a -> b -> c -> d -> e) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n 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) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n 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) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n f -> Vector v n g

-- | <i>O(n)</i> Zip two vectors of the same length with a function that
--   also takes the elements' indices).
izipWith :: (Vector v a, Vector v b, Vector v c) => (Finite n -> a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c
izipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (Finite n -> a -> b -> c -> d) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d
izipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (Finite n -> a -> b -> c -> d -> e) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e
izipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f) => (Finite n -> a -> b -> c -> d -> e -> f) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n f
izipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g) => (Finite n -> a -> b -> c -> d -> e -> f -> g) -> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n f -> Vector v n g

-- | <i>O(n)</i> Zip two vectors of the same length
zip :: (Vector v a, Vector v b, Vector v (a, b)) => Vector v n a -> Vector v n b -> Vector v n (a, b)
zip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => Vector v n a -> Vector v n b -> Vector v n c -> Vector v n (a, b, c)
zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n (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)) => Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n (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)) => Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n f -> Vector v n (a, b, c, d, e, f)

-- | <i>O(n)</i> Zip the two vectors of the same length with the monadic
--   action and yield a vector of results.
zipWithM :: (Monad m, Vector v a, Vector v b, Vector v c) => (a -> b -> m c) -> Vector v n a -> Vector v n b -> m (Vector v n c)

-- | <i>O(n)</i> Zip the two vectors with a monadic action that also takes
--   the element index and yield a vector of results.
izipWithM :: (Monad m, Vector v a, Vector v b, Vector v c) => (Finite n -> a -> b -> m c) -> Vector v n a -> Vector v n b -> m (Vector v n c)

-- | <i>O(n)</i> Zip the two vectors with the monadic action and ignore the
--   results.
zipWithM_ :: (Monad m, Vector v a, Vector v b) => (a -> b -> m c) -> Vector v n a -> Vector v n b -> m ()

-- | <i>O(n)</i> Zip the two vectors with a monadic action that also takes
--   the element index and ignore the results.
izipWithM_ :: (Monad m, Vector v a, Vector v b) => (Finite n -> a -> b -> m c) -> Vector v n a -> Vector v n b -> m ()

-- | <i>O(min(m,n))</i> Unzip a vector of pairs.
unzip :: (Vector v a, Vector v b, Vector v (a, b)) => Vector v n (a, b) -> (Vector v n a, Vector v n b)
unzip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) => Vector v n (a, b, c) -> (Vector v n a, Vector v n b, Vector v n c)
unzip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => Vector v n (a, b, c, d) -> (Vector v n a, Vector v n b, Vector v n c, Vector v n d)
unzip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => Vector v n (a, b, c, d, e) -> (Vector v n a, Vector v n b, Vector v n c, Vector v n d, Vector v n 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)) => Vector v n (a, b, c, d, e, f) -> (Vector v n a, Vector v n b, Vector v n c, Vector v n d, Vector v n e, Vector v n f)

-- | <i>O(n)</i> Check if the vector contains an element.
elem :: (Vector v a, Eq a) => a -> Vector v n a -> Bool
infix 4 `elem`

-- | <i>O(n)</i> Check if the vector does not contain an element (inverse
--   of <a>elem</a>).
notElem :: (Vector v a, Eq a) => a -> Vector v n a -> Bool
infix 4 `notElem`

-- | <i>O(n)</i> Yield <a>Just</a> the first element matching the predicate
--   or <a>Nothing</a> if no such element exists.
find :: Vector v a => (a -> Bool) -> Vector v n a -> Maybe a

-- | <i>O(n)</i> Yield <a>Just</a> the index of the first element matching
--   the predicate or <a>Nothing</a> if no such element exists.
findIndex :: Vector v a => (a -> Bool) -> Vector v n a -> Maybe (Finite n)

-- | <i>O(n)</i> Yield <a>Just</a> the index of the first occurence of the
--   given element or <a>Nothing</a> if the vector does not contain the
--   element. This is a specialised version of <a>findIndex</a>.
elemIndex :: (Vector v a, Eq a) => a -> Vector v n a -> Maybe (Finite n)

-- | <i>O(n)</i> Left fold.
foldl :: Vector v b => (a -> b -> a) -> a -> Vector v n b -> a

-- | <i>O(n)</i> Left fold on non-empty vectors.
foldl1 :: Vector v a => (a -> a -> a) -> Vector v (1 + n) a -> a

-- | <i>O(n)</i> Left fold with strict accumulator.
foldl' :: Vector v b => (a -> b -> a) -> a -> Vector v n b -> a

-- | <i>O(n)</i> Left fold on non-empty vectors with strict accumulator.
foldl1' :: Vector v a => (a -> a -> a) -> Vector v (1 + n) a -> a

-- | <i>O(n)</i> Right fold.
foldr :: Vector v a => (a -> b -> b) -> b -> Vector v n a -> b

-- | <i>O(n)</i> Right fold on non-empty vectors.
foldr1 :: Vector v a => (a -> a -> a) -> Vector v (n + 1) a -> a

-- | <i>O(n)</i> Right fold with a strict accumulator.
foldr' :: Vector v a => (a -> b -> b) -> b -> Vector v n a -> b

-- | <i>O(n)</i> Right fold on non-empty vectors with strict accumulator.
foldr1' :: Vector v a => (a -> a -> a) -> Vector v (n + 1) a -> a

-- | <i>O(n)</i> Left fold (function applied to each element and its
--   index).
ifoldl :: Vector v b => (a -> Finite n -> b -> a) -> a -> Vector v n b -> a

-- | <i>O(n)</i> Left fold with strict accumulator (function applied to
--   each element and its index).
ifoldl' :: Vector v b => (a -> Finite n -> b -> a) -> a -> Vector v n b -> a

-- | <i>O(n)</i> Right fold (function applied to each element and its
--   index).
ifoldr :: Vector v a => (Finite n -> a -> b -> b) -> b -> Vector v n a -> b

-- | <i>O(n)</i> Right fold with strict accumulator (function applied to
--   each element and its index).
ifoldr' :: Vector v a => (Finite n -> a -> b -> b) -> b -> Vector v n a -> b

-- | <i>O(n)</i> Check if all elements satisfy the predicate.
all :: Vector v a => (a -> Bool) -> Vector v n a -> Bool

-- | <i>O(n)</i> Check if any element satisfies the predicate.
any :: Vector v a => (a -> Bool) -> Vector v n a -> Bool

-- | <i>O(n)</i> Check if all elements are <a>True</a>
and :: Vector v Bool => Vector v n Bool -> Bool

-- | <i>O(n)</i> Check if any element is <a>True</a>
or :: Vector v Bool => Vector v n Bool -> Bool

-- | <i>O(n)</i> Compute the sum of the elements.
sum :: (Vector v a, Num a) => Vector v n a -> a

-- | <i>O(n)</i> Compute the product of the elements.
product :: (Vector v a, Num a) => Vector v n a -> a

-- | <i>O(n)</i> Yield the maximum element of the non-empty vector.
maximum :: (Vector v a, Ord a) => Vector v (n + 1) a -> a

-- | <i>O(n)</i> Yield the maximum element of the non-empty vector
--   according to the given comparison function.
maximumBy :: Vector v a => (a -> a -> Ordering) -> Vector v (n + 1) a -> a

-- | <i>O(n)</i> Yield the minimum element of the non-empty vector.
minimum :: (Vector v a, Ord a) => Vector v (n + 1) a -> a

-- | <i>O(n)</i> Yield the minimum element of the non-empty vector
--   according to the given comparison function.
minimumBy :: Vector v a => (a -> a -> Ordering) -> Vector v (n + 1) a -> a

-- | <i>O(n)</i> Yield the index of the maximum element of the non-empty
--   vector.
maxIndex :: (Vector v a, Ord a) => Vector v (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the maximum element of the non-empty
--   vector according to the given comparison function.
maxIndexBy :: Vector v a => (a -> a -> Ordering) -> Vector v (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the minimum element of the non-empty
--   vector.
minIndex :: (Vector v a, Ord a) => Vector v (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the minimum element of the non-empty
--   vector according to the given comparison function.
minIndexBy :: Vector v a => (a -> a -> Ordering) -> Vector v (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Monadic fold.
foldM :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> Vector v n b -> m a

-- | <i>O(n)</i> Monadic fold (action applied to each element and its
--   index).
ifoldM :: (Monad m, Vector v b) => (a -> Finite n -> b -> m a) -> a -> Vector v n b -> m a

-- | <i>O(n)</i> Monadic fold over non-empty vectors.
fold1M :: (Monad m, Vector v a) => (a -> a -> m a) -> Vector v (1 + n) a -> m a

-- | <i>O(n)</i> Monadic fold with strict accumulator.
foldM' :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> Vector v n b -> m a

-- | <i>O(n)</i> Monadic fold with strict accumulator (action applied to
--   each element and its index).
ifoldM' :: (Monad m, Vector v b) => (a -> Finite n -> b -> m a) -> a -> Vector v n b -> m a

-- | <i>O(n)</i> Monadic fold over non-empty vectors with strict
--   accumulator.
fold1M' :: (Monad m, Vector v a) => (a -> a -> m a) -> Vector v (n + 1) a -> m a

-- | <i>O(n)</i> Monadic fold that discards the result.
foldM_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> Vector v n b -> m ()

-- | <i>O(n)</i> Monadic fold that discards the result (action applied to
--   each element and its index).
ifoldM_ :: (Monad m, Vector v b) => (a -> Finite n -> b -> m a) -> a -> Vector v n b -> m ()

-- | <i>O(n)</i> Monadic fold over non-empty vectors that discards the
--   result.
fold1M_ :: (Monad m, Vector v a) => (a -> a -> m a) -> Vector v (n + 1) a -> m ()

-- | <i>O(n)</i> Monadic fold with strict accumulator that discards the
--   result.
foldM'_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> Vector v n b -> m ()

-- | <i>O(n)</i> Monadic fold with strict accumulator that discards the
--   result (action applied to each element and its index).
ifoldM'_ :: (Monad m, Vector v b) => (a -> Finite n -> b -> m a) -> a -> Vector v n b -> m ()

-- | <i>O(n)</i> Monad fold over non-empty vectors with strict accumulator
--   that discards the result.
fold1M'_ :: (Monad m, Vector v a) => (a -> a -> m a) -> Vector v (n + 1) a -> m ()

-- | Evaluate each action and collect the results.
sequence :: (Monad m, Vector v a, Vector v (m a)) => Vector v n (m a) -> m (Vector v n a)

-- | Evaluate each action and discard the results.
sequence_ :: (Monad m, Vector v (m a)) => Vector v n (m a) -> m ()

-- | <i>O(n)</i> Prescan
--   
--   <pre>
--   prescanl f z = <a>init</a> . <a>scanl</a> f z
--   </pre>
--   
--   Example: <tt>prescanl (+) 0 &lt;1,2,3,4&gt; = &lt;0,1,3,6&gt;</tt>
prescanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a

-- | <i>O(n)</i> Prescan with strict accumulator.
prescanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a

-- | <i>O(n)</i> Scan
postscanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a

-- | <i>O(n)</i> Scan with strict accumulator.
postscanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a

-- | <i>O(n)</i> Haskell-style scan.
scanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v (1 + n) a

-- | <i>O(n)</i> Haskell-style scan with strict accumulator.
scanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v (1 + n) a

-- | <i>O(n)</i> Scan over a non-empty vector.
scanl1 :: Vector v a => (a -> a -> a) -> Vector v (1 + n) a -> Vector v (2 + n) a

-- | <i>O(n)</i> Scan over a non-empty vector with a strict accumulator.
scanl1' :: Vector v a => (a -> a -> a) -> Vector v (1 + n) a -> Vector v (2 + n) a

-- | <i>O(n)</i> Right-to-left prescan.
prescanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b

-- | <i>O(n)</i> Right-to-left prescan with strict accumulator.
prescanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b

-- | <i>O(n)</i> Right-to-left scan.
postscanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b

-- | <i>O(n)</i> Right-to-left scan with strict accumulator.
postscanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b

-- | <i>O(n)</i> Right-to-left Haskell-style scan.
scanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v (n + 1) b

-- | <i>O(n)</i> Right-to-left Haskell-style scan with strict accumulator.
scanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v (n + 1) b

-- | <i>O(n)</i> Right-to-left scan over a non-empty vector.
scanr1 :: Vector v a => (a -> a -> a) -> Vector v (n + 1) a -> Vector v (n + 2) a

-- | <i>O(n)</i> Right-to-left scan over a non-empty vector with a strict
--   accumulator.
scanr1' :: Vector v a => (a -> a -> a) -> Vector v (n + 1) a -> Vector v (n + 2) a

-- | <i>O(n)</i> Convert a vector to a list.
toList :: Vector v a => Vector v n a -> [a]

-- | <i>O(n)</i> Convert a list to a vector.
fromList :: (Vector v a, KnownNat n) => [a] -> Maybe (Vector v n a)

-- | <i>O(n)</i> Convert the first <tt>n</tt> elements of a list to a
--   vector. The length of the resultant vector is inferred from the type.
fromListN :: forall v n a. (Vector v a, KnownNat n) => [a] -> Maybe (Vector v n a)

-- | <i>O(n)</i> Convert the first <tt>n</tt> elements of a list to a
--   vector. The length of the resultant vector is given explicitly as a
--   <a>Proxy</a> argument.
fromListN' :: forall v n a p. (Vector v a, KnownNat n) => p n -> [a] -> Maybe (Vector v n a)

-- | <i>O(n)</i> Takes a list and returns a continuation providing a vector
--   with a size parameter corresponding to the length of the list.
--   
--   Essentially converts a list into a vector with the proper size
--   parameter, determined at runtime.
--   
--   See <a>withSized</a>
withSizedList :: forall v a r. Vector v a => [a] -> (forall n. KnownNat n => Vector v n a -> r) -> r

-- | <i>O(n)</i> Convert different vector types.
convert :: (Vector v a, Vector w a) => Vector v n a -> Vector w n a

-- | <i>O(n)</i> Yield an immutable copy of the mutable vector.
freeze :: (PrimMonad m, Vector v a) => MVector (Mutable v) n (PrimState m) a -> m (Vector v n a)

-- | <i>O(n)</i> Yield a mutable copy of the immutable vector.
thaw :: (PrimMonad m, Vector v a) => Vector v n a -> m (MVector (Mutable v) n (PrimState m) a)

-- | <i>O(n)</i> Copy an immutable vector into a mutable one.
copy :: (PrimMonad m, Vector v a) => MVector (Mutable v) n (PrimState m) a -> Vector v n a -> m ()

-- | <i>O(1)</i> Unsafely convert a mutable vector to an immutable one
--   withouy copying. The mutable vector may not be used after this
--   operation.
unsafeFreeze :: (PrimMonad m, Vector v a) => MVector (Mutable v) n (PrimState m) a -> m (Vector v n a)

-- | <i>O(n)</i> Unsafely convert an immutable vector to a mutable one
--   without copying. The immutable vector may not be used after this
--   operation.
unsafeThaw :: (PrimMonad m, Vector v a) => Vector v n a -> m (MVector (Mutable v) n (PrimState m) a)

-- | Convert a <a>Vector</a> into a <a>Vector</a> if it has the correct
--   size, otherwise return Nothing.
toSized :: forall v n a. (Vector v a, KnownNat n) => v a -> Maybe (Vector v n a)

-- | Takes a <a>Vector</a> and returns a continuation providing a
--   <a>Sized</a> with a size parameter <tt>n</tt> that is determined at
--   runtime based on the length of the input vector.
--   
--   Essentially converts a <a>Vector</a> into a <a>Vector</a> with the
--   correct size parameter <tt>n</tt>.
withSized :: forall v a r. Vector v a => v a -> (forall n. KnownNat n => Vector v n a -> r) -> r
fromSized :: Vector v n a -> v a

-- | Apply a function on unsized vectors to a sized vector. The function
--   must preserve the size of the vector, this is not checked.
withVectorUnsafe :: (v a -> w b) -> Vector v n a -> Vector w n b

-- | Apply a function on two unsized vectors to sized vectors. The function
--   must preserve the size of the vectors, this is not checked.
zipVectorsUnsafe :: (u a -> v b -> w c) -> Vector u n a -> Vector v n b -> Vector w n c
instance (GHC.TypeNats.KnownNat n, Data.Vector.Generic.Base.Vector v a, GHC.Read.Read (v a)) => GHC.Read.Read (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance (GHC.TypeNats.KnownNat n, Foreign.Storable.Storable a, Data.Vector.Generic.Base.Vector v a) => Foreign.Storable.Storable (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance GHC.TypeNats.KnownNat n => GHC.Base.Applicative (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Vector n)
instance GHC.TypeNats.KnownNat n => GHC.Base.Monad (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Vector n)
instance (GHC.TypeNats.KnownNat n, n GHC.Types.~ (1 GHC.TypeNats.+ m)) => Control.Comonad.Comonad (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Vector n)
instance (GHC.TypeNats.KnownNat n, n GHC.Types.~ (1 GHC.TypeNats.+ m)) => Control.Comonad.ComonadApply (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Vector n)
instance (GHC.Base.Semigroup g, Data.Vector.Generic.Base.Vector v g) => GHC.Base.Semigroup (Data.Vector.Generic.Sized.Internal.Vector v n g)
instance (GHC.Base.Monoid m, Data.Vector.Generic.Base.Vector v m, GHC.TypeNats.KnownNat n) => GHC.Base.Monoid (Data.Vector.Generic.Sized.Internal.Vector v n m)
instance GHC.TypeNats.KnownNat n => Data.Distributive.Distributive (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Vector n)
instance GHC.TypeNats.KnownNat n => Data.Functor.Rep.Representable (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Vector n)
instance (GHC.Classes.Eq a, Data.Hashable.Class.Hashable a) => Data.Hashable.Class.Hashable (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Vector n a)
instance (GHC.Classes.Eq a, Data.Hashable.Class.Hashable a, Foreign.Storable.Storable a) => Data.Hashable.Class.Hashable (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Storable.Vector n a)
instance (GHC.Classes.Eq a, Data.Hashable.Class.Hashable a, Data.Vector.Unboxed.Base.Unbox a) => Data.Hashable.Class.Hashable (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Unboxed.Base.Vector n a)
instance (Data.Vector.Generic.Base.Vector v a, GHC.Num.Num a, GHC.TypeNats.KnownNat n) => GHC.Num.Num (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance (Data.Vector.Generic.Base.Vector v a, GHC.Real.Fractional a, GHC.TypeNats.KnownNat n) => GHC.Real.Fractional (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance (Data.Vector.Generic.Base.Vector v a, GHC.Float.Floating a, GHC.TypeNats.KnownNat n) => GHC.Float.Floating (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance (Data.Vector.Generic.Base.Vector v a, Data.Binary.Class.Binary a, GHC.TypeNats.KnownNat n) => Data.Binary.Class.Binary (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance (Data.Vector.Generic.Base.Vector v a, Data.Bits.Bits (v a), Data.Bits.Bits a, GHC.TypeNats.KnownNat n) => Data.Bits.Bits (Data.Vector.Generic.Sized.Internal.Vector v n a)
instance (Data.Vector.Generic.Base.Vector v a, Data.Bits.Bits (v a), Data.Bits.FiniteBits a, GHC.TypeNats.KnownNat n) => Data.Bits.FiniteBits (Data.Vector.Generic.Sized.Internal.Vector v n a)


-- | This module re-exports the functionality in <a>Sized</a> specialized
--   to <a>Mutable</a>.
--   
--   Functions returning a vector determine the size from the type context
--   unless they have a <tt>'</tt> suffix in which case they take an
--   explicit <a>Proxy</a> argument.
--   
--   Functions where the resulting vector size is not known until runtime
--   are not exported.
module Data.Vector.Mutable.Sized

-- | <a>Vector</a> specialized to use <a>Mutable</a>.
type MVector = MVector MVector

-- | <i>O(1)</i> Yield the length of the mutable vector as an <a>Int</a>.
length :: forall n s a. KnownNat n => MVector n s a -> Int

-- | <i>O(1)</i> Yield the length of the mutable vector as a <a>Proxy</a>.
length' :: forall n s a. () => MVector n s a -> Proxy n

-- | <i>O(1)</i> Check whether the mutable vector is empty.
null :: forall n s a. KnownNat n => MVector n s a -> Bool

-- | <i>O(1)</i> Yield a slice of the mutable vector without copying it
--   with an inferred length argument.
slice :: forall i n k s a p. (KnownNat i, KnownNat n) => p i -> MVector ((i + n) + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield a slice of the mutable vector without copying it
--   with an explicit length argument.
slice' :: forall i n k s a p. (KnownNat i, KnownNat n) => p i -> p n -> MVector ((i + n) + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the last element of a non-empty mutable
--   vector without copying.
init :: forall n s a. () => MVector (n + 1) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the first element of a non-empty mutable
--   vector without copying.
tail :: forall n s a. () => MVector (1 + n) s a -> MVector n s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is inferred from the type.
take :: forall n k s a. KnownNat n => MVector (n + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is given explicitly as a <a>Proxy</a> argument.
take' :: forall n k s a p. KnownNat n => p n -> MVector (n + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is inferred from the type.
drop :: forall n k s a. KnownNat n => MVector (n + k) s a -> MVector k s a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is given explicitly as a <a>Proxy</a> argument.
drop' :: forall n k s a p. KnownNat n => p n -> MVector (n + k) s a -> MVector k s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The lengths of the resulting vectors are inferred
--   from the type.
splitAt :: forall n m s a. KnownNat n => MVector (n + m) s a -> (MVector n s a, MVector m s a)

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The length of the first resulting vector is passed
--   explicitly as a <a>Proxy</a> argument.
splitAt' :: forall n m s a p. KnownNat n => p n -> MVector (n + m) s a -> (MVector n s a, MVector m s a)

-- | <i>O(1)</i> Check if two vectors overlap.
overlaps :: forall n k s a. () => MVector n s a -> MVector k s a -> Bool

-- | Create a mutable vector where the length is inferred from the type.
new :: forall n m a. (KnownNat n, PrimMonad m) => m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type.
--   The memory is not initialized.
unsafeNew :: forall n m a. (KnownNat n, PrimMonad m) => m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type and
--   fill it with an initial value.
replicate :: forall n m a. (KnownNat n, PrimMonad m) => a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is given explicitly as a
--   <a>Proxy</a> argument and fill it with an initial value.
replicate' :: forall n m a p. (KnownNat n, PrimMonad m) => p n -> a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type and
--   fill it with values produced by repeatedly executing the monadic
--   action.
replicateM :: forall n m a. (KnownNat n, PrimMonad m) => m a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is given explicitly as a
--   <a>Proxy</a> argument and fill it with values produced by repeatedly
--   executing the monadic action.
replicateM' :: forall n m a p. (KnownNat n, PrimMonad m) => p n -> m a -> m (MVector n (PrimState m) a)

-- | Create a copy of a mutable vector.
clone :: forall n m a. PrimMonad m => MVector n (PrimState m) a -> m (MVector n (PrimState m) a)

-- | Grow a mutable vector by an amount given explicitly as a <a>Proxy</a>
--   argument.
grow :: forall n k m a p. (KnownNat k, PrimMonad m) => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)

-- | Grow a mutable vector (from the front) by an amount given explicitly
--   as a <a>Proxy</a> argument.
growFront :: forall n k m a p. (KnownNat k, PrimMonad m) => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)

-- | Reset all elements of the vector to some undefined value, clearing all
--   references to external objects.
clear :: PrimMonad m => MVector n (PrimState m) a -> m ()

-- | <i>O(1)</i> Yield the element at a given type-safe position using
--   <a>Finite</a>.
read :: forall n m a. PrimMonad m => MVector n (PrimState m) a -> Finite n -> m a

-- | <i>O(1)</i> Yield the element at a given type-safe position using
--   <a>Proxy</a>.
read' :: forall n k a m p. (KnownNat k, PrimMonad m) => MVector ((n + k) + 1) (PrimState m) a -> p k -> m a

-- | <i>O(1)</i> Replace the element at a given type-safe position using
--   <a>Finite</a>.
write :: forall n m a. PrimMonad m => MVector n (PrimState m) a -> Finite n -> a -> m ()

-- | <i>O(1)</i> Replace the element at a given type-safe position using
--   <a>Proxy</a>.
write' :: forall n k a m p. (KnownNat k, PrimMonad m) => MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m ()

-- | <i>O(1)</i> Modify the element at a given type-safe position using
--   <a>Finite</a>.
modify :: forall n m a. PrimMonad m => MVector n (PrimState m) a -> (a -> a) -> Finite n -> m ()

-- | <i>O(1)</i> Modify the element at a given type-safe position using
--   <a>Proxy</a>.
modify' :: forall n k a m p. (KnownNat k, PrimMonad m) => MVector ((n + k) + 1) (PrimState m) a -> (a -> a) -> p k -> m ()

-- | <i>O(1)</i> Swap the elements at the given type-safe positions using
--   <a>Finite</a>s.
swap :: forall n m a. PrimMonad m => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()

-- | <i>O(1)</i> Replace the element at a given type-safe position and
--   return the old element, using <a>Finite</a>.
exchange :: forall n m a. PrimMonad m => MVector n (PrimState m) a -> Finite n -> a -> m a

-- | <i>O(1)</i> Replace the element at a given type-safe position and
--   return the old element, using <a>Finite</a>.
exchange' :: forall n k a m p. (KnownNat k, PrimMonad m) => MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m a

-- | <i>O(1)</i> Yield the element at a given <a>Int</a> position without
--   bounds checking.
unsafeRead :: forall n a m. PrimMonad m => MVector n (PrimState m) a -> Int -> m a

-- | <i>O(1)</i> Replace the element at a given <a>Int</a> position without
--   bounds checking.
unsafeWrite :: forall n m a. PrimMonad m => MVector n (PrimState m) a -> Int -> a -> m ()

-- | <i>O(1)</i> Modify the element at a given <a>Int</a> position without
--   bounds checking.
unsafeModify :: forall n m a. PrimMonad m => MVector n (PrimState m) a -> (a -> a) -> Int -> m ()

-- | <i>O(1)</i> Swap the elements at the given <a>Int</a> positions
--   without bounds checking.
unsafeSwap :: forall n m a. PrimMonad m => MVector n (PrimState m) a -> Int -> Int -> m ()

-- | <i>O(1)</i> Replace the element at a given <a>Int</a> position and
--   return the old element. No bounds checks are performed.
unsafeExchange :: forall n m a. PrimMonad m => MVector n (PrimState m) a -> Int -> a -> m a

-- | Compute the next permutation (lexicographically) of a given vector
--   in-place. Returns <a>False</a> when the input is the last permutation.
nextPermutation :: forall n e m. (Ord e, PrimMonad m) => MVector n (PrimState m) e -> m Bool

-- | Set all elements of the vector to the given value.
set :: PrimMonad m => MVector n (PrimState m) a -> a -> m ()

-- | Copy a vector. The two vectors may not overlap.
copy :: PrimMonad m => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Move the contents of a vector. If the two vectors do not overlap, this
--   is equivalent to <a>copy</a>. Otherwise, the copying is performed as
--   if the source vector were copied to a temporary vector and then the
--   temporary vector was copied to the target vector.
move :: PrimMonad m => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Copy a vector. The two vectors may not overlap. This is not checked.
unsafeCopy :: PrimMonad m => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Convert a <a>MVector</a> into a <a>MVector</a> if it has the correct
--   size, otherwise return <a>Nothing</a>.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
toSized :: forall n a s. KnownNat n => MVector s a -> Maybe (MVector n s a)

-- | Takes a <a>MVector</a> and returns a continuation providing a
--   <a>MVector</a> with a size parameter <tt>n</tt> that is determined at
--   runtime based on the length of the input vector.
--   
--   Essentially converts a <a>MVector</a> into a <a>MVector</a> with the
--   correct size parameter <tt>n</tt>.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
withSized :: forall s a r. () => MVector s a -> (forall n. KnownNat n => MVector n s a -> r) -> r

-- | Convert a <a>MVector</a> into a <a>MVector</a>.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
fromSized :: MVector n s a -> MVector s a


-- | This module re-exports the functionality in <a>Sized</a> specialized
--   to <a>Mutable</a>.
--   
--   Functions returning a vector determine the size from the type context
--   unless they have a <tt>'</tt> suffix in which case they take an
--   explicit <a>Proxy</a> argument.
--   
--   Functions where the resulting vector size is not known until runtime
--   are not exported.
module Data.Vector.Primitive.Mutable.Sized

-- | <a>Vector</a> specialized to use <a>Mutable</a>.
type MVector = MVector MVector

-- | <i>O(1)</i> Yield the length of the mutable vector as an <a>Int</a>.
length :: forall n s a. KnownNat n => MVector n s a -> Int

-- | <i>O(1)</i> Yield the length of the mutable vector as a <a>Proxy</a>.
length' :: forall n s a. () => MVector n s a -> Proxy n

-- | <i>O(1)</i> Check whether the mutable vector is empty.
null :: forall n s a. KnownNat n => MVector n s a -> Bool

-- | <i>O(1)</i> Yield a slice of the mutable vector without copying it
--   with an inferred length argument.
slice :: forall i n k s a p. (KnownNat i, KnownNat n, Prim a) => p i -> MVector ((i + n) + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield a slice of the mutable vector without copying it
--   with an explicit length argument.
slice' :: forall i n k s a p. (KnownNat i, KnownNat n, Prim a) => p i -> p n -> MVector ((i + n) + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the last element of a non-empty mutable
--   vector without copying.
init :: forall n s a. Prim a => MVector (n + 1) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the first element of a non-empty mutable
--   vector without copying.
tail :: forall n s a. Prim a => MVector (1 + n) s a -> MVector n s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is inferred from the type.
take :: forall n k s a. (KnownNat n, Prim a) => MVector (n + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is given explicitly as a <a>Proxy</a> argument.
take' :: forall n k s a p. (KnownNat n, Prim a) => p n -> MVector (n + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is inferred from the type.
drop :: forall n k s a. (KnownNat n, Prim a) => MVector (n + k) s a -> MVector k s a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is givel explicitly as a <a>Proxy</a> argument.
drop' :: forall n k s a p. (KnownNat n, Prim a) => p n -> MVector (n + k) s a -> MVector k s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The lengths of the resulting vectors are inferred
--   from the type.
splitAt :: forall n m s a. (KnownNat n, Prim a) => MVector (n + m) s a -> (MVector n s a, MVector m s a)

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The length of the first resulting vector is passed
--   explicitly as a <a>Proxy</a> argument.
splitAt' :: forall n m s a p. (KnownNat n, Prim a) => p n -> MVector (n + m) s a -> (MVector n s a, MVector m s a)

-- | <i>O(1)</i> Check if two vectors overlap.
overlaps :: forall n k s a. Prim a => MVector n s a -> MVector k s a -> Bool

-- | Create a mutable vector where the length is inferred from the type.
new :: forall n m a. (KnownNat n, PrimMonad m, Prim a) => m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type.
--   The memory is not initialized.
unsafeNew :: forall n m a. (KnownNat n, PrimMonad m, Prim a) => m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type and
--   fill it with an initial value.
replicate :: forall n m a. (KnownNat n, PrimMonad m, Prim a) => a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is given explicitly as a
--   <a>Proxy</a> argument and fill it with an initial value.
replicate' :: forall n m a p. (KnownNat n, PrimMonad m, Prim a) => p n -> a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type and
--   fill it with values produced by repeatedly executing the monadic
--   action.
replicateM :: forall n m a. (KnownNat n, PrimMonad m, Prim a) => m a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is given explicitly as a
--   <a>Proxy</a> argument and fill it with values produced by repeatedly
--   executing the monadic action.
replicateM' :: forall n m a p. (KnownNat n, PrimMonad m, Prim a) => p n -> m a -> m (MVector n (PrimState m) a)

-- | Create a copy of a mutable vector.
clone :: forall n m a. (PrimMonad m, Prim a) => MVector n (PrimState m) a -> m (MVector n (PrimState m) a)

-- | Grow a mutable vector by an amount given explicitly as a <a>Proxy</a>
--   argument.
grow :: forall n k m a p. (KnownNat k, PrimMonad m, Prim a) => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)

-- | Grow a mutable vector (from the front) by an amount given explicitly
--   as a <a>Proxy</a> argument.
growFront :: forall n k m a p. (KnownNat k, PrimMonad m, Prim a) => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)

-- | Reset all elements of the vector to some undefined value, clearing all
--   references to external objects.
clear :: (PrimMonad m, Prim a) => MVector n (PrimState m) a -> m ()

-- | <i>O(1)</i> Yield the element at a given type-safe position using
--   <a>Finite</a>.
read :: forall n m a. (PrimMonad m, Prim a) => MVector n (PrimState m) a -> Finite n -> m a

-- | <i>O(1)</i> Yield the element at a given type-safe position using
--   <a>Proxy</a>.
read' :: forall n k a m p. (KnownNat k, PrimMonad m, Prim a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> m a

-- | <i>O(1)</i> Replace the element at a given type-safe position using
--   <a>Finite</a>.
write :: forall n m a. (PrimMonad m, Prim a) => MVector n (PrimState m) a -> Finite n -> a -> m ()

-- | <i>O(1)</i> Replace the element at a given type-safe position using
--   <a>Proxy</a>.
write' :: forall n k a m p. (KnownNat k, PrimMonad m, Prim a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m ()

-- | <i>O(1)</i> Modify the element at a given type-safe position using
--   <a>Finite</a>.
modify :: forall n m a. (PrimMonad m, Prim a) => MVector n (PrimState m) a -> (a -> a) -> Finite n -> m ()

-- | <i>O(1)</i> Modify the element at a given type-safe position using
--   <a>Proxy</a>.
modify' :: forall n k a m p. (KnownNat k, PrimMonad m, Prim a) => MVector ((n + k) + 1) (PrimState m) a -> (a -> a) -> p k -> m ()

-- | <i>O(1)</i> Swap the elements at the given type-safe positions using
--   <a>Finite</a>s.
swap :: forall n m a. (PrimMonad m, Prim a) => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()

-- | <i>O(1)</i> Replace the element at a given type-safe position and
--   return the old element, using <a>Finite</a>.
exchange :: forall n m a. (PrimMonad m, Prim a) => MVector n (PrimState m) a -> Finite n -> a -> m a

-- | <i>O(1)</i> Replace the element at a given type-safe position and
--   return the old element, using <a>Finite</a>.
exchange' :: forall n k a m p. (KnownNat k, PrimMonad m, Prim a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m a

-- | <i>O(1)</i> Yield the element at a given <a>Int</a> position without
--   bounds checking.
unsafeRead :: forall n a m. (PrimMonad m, Prim a) => MVector n (PrimState m) a -> Int -> m a

-- | <i>O(1)</i> Replace the element at a given <a>Int</a> position without
--   bounds checking.
unsafeWrite :: forall n m a. (PrimMonad m, Prim a) => MVector n (PrimState m) a -> Int -> a -> m ()

-- | <i>O(1)</i> Modify the element at a given <a>Int</a> position without
--   bounds checking.
unsafeModify :: forall n m a. (PrimMonad m, Prim a) => MVector n (PrimState m) a -> (a -> a) -> Int -> m ()

-- | <i>O(1)</i> Swap the elements at the given <a>Int</a> positions
--   without bounds checking.
unsafeSwap :: forall n m a. (PrimMonad m, Prim a) => MVector n (PrimState m) a -> Int -> Int -> m ()

-- | <i>O(1)</i> Replace the element at a given <a>Int</a> position and
--   return the old element. No bounds checks are performed.
unsafeExchange :: forall n m a. (PrimMonad m, Prim a) => MVector n (PrimState m) a -> Int -> a -> m a

-- | Compute the next permutation (lexicographically) of a given vector
--   in-place. Returns <a>False</a> when the input is the last permutation.
nextPermutation :: forall n e m. (Ord e, PrimMonad m, Prim e) => MVector n (PrimState m) e -> m Bool

-- | Set all elements of the vector to the given value.
set :: (PrimMonad m, Prim a) => MVector n (PrimState m) a -> a -> m ()

-- | Copy a vector. The two vectors may not overlap.
copy :: (PrimMonad m, Prim a) => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Move the contents of a vector. If the two vectors do not overlap, this
--   is equivalent to <a>copy</a>. Otherwise, the copying is performed as
--   if the source vector were copied to a temporary vector and then the
--   temporary vector was copied to the target vector.
move :: (PrimMonad m, Prim a) => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Copy a vector. The two vectors may not overlap. This is not checked.
unsafeCopy :: (PrimMonad m, Prim a) => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Convert a <a>MVector</a> into a <a>MVector</a> if it has the correct
--   size, otherwise return Nothing.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
toSized :: forall n a s. (KnownNat n, Prim a) => MVector s a -> Maybe (MVector n s a)

-- | Takes a <a>MVector</a> and returns a continuation providing a
--   <a>MVector</a> with a size parameter <tt>n</tt> that is determined at
--   runtime based on the length of the input vector.
--   
--   Essentially converts a <a>MVector</a> into a <a>MVector</a> with the
--   correct size parameter <tt>n</tt>.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
withSized :: forall s a r. Prim a => MVector s a -> (forall n. KnownNat n => MVector n s a -> r) -> r

-- | Convert a <a>MVector</a> into a <a>MVector</a>.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
fromSized :: MVector n s a -> MVector s a


-- | This module re-exports the functionality in <a>Sized</a> specialized
--   to <a>Primitive</a>.
--   
--   Functions returning a vector determine the size from the type context
--   unless they have a <tt>'</tt> suffix in which case they take an
--   explicit <a>Proxy</a> argument.
--   
--   Functions where the resulting vector size is not known until runtime
--   are not exported.
module Data.Vector.Primitive.Sized

-- | <a>Vector</a> specialized to use <a>Primitive</a>.
type Vector = Vector Vector

-- | Pattern synonym that lets you treat an unsized vector as if it
--   "contained" a sized vector. If you pattern match on an unsized vector,
--   its contents will be the <i>sized</i> vector counterpart.
--   
--   <pre>
--   testFunc :: Unsized.Vector Int -&gt; Int
--   testFunc (<a>SomeSized</a> v) =
--       <a>sum</a> (<a>zipWith</a> (+) v (<a>replicate</a> 1))
--           -- ^ here, v is `Sized.Vector n Int`, and we have
--                       `<a>KnownNat</a> n`
--   </pre>
--   
--   The <tt>n</tt> type variable will be properly instantiated to whatever
--   the length of the vector is, and you will also have a
--   <tt><a>KnownNat</a> n</tt> instance available. You can get <tt>n</tt>
--   in scope by turning on ScopedTypeVariables and matching on
--   <tt><a>SomeSized</a> (v :: Sized.Vector n Int)</tt>.
--   
--   Without this, you would otherwise have to use <a>withSized</a> to do
--   the same thing:
--   
--   <pre>
--   testFunc :: Unsized.Vector Int -&gt; Int
--   testFunc u = <a>withSized</a> u $ \v -&gt;
--       <a>sum</a> (<a>zipWith</a> (+) v (<a>replicate</a> 1))
--   </pre>
--   
--   Remember that the type of final result of your function (the
--   <tt>Int</tt>, here) must <i>not</i> depend on <tt>n</tt>. However, the
--   types of the intermediate values are allowed to depend on <tt>n</tt>.
--   
--   This is <i>especially</i> useful in do blocks, where you can pattern
--   match on the unsized results of actions, to use the sized vector in
--   the rest of the do block. You also get a <tt><a>KnownNat</a> n</tt>
--   constraint for the remainder of the do block.
--   
--   <pre>
--   -- If you had:
--   getAVector :: IO (Unsized.Vector Int)
--   
--   main :: IO ()
--   main = do
--       SomeSized v &lt;- getAVector -- v is `Sized.Vector n Int`
--       -- get n in scope
--       SomeSized (v :: Sized.Vector n Int) &lt;- getAVector
--       print v
--   </pre>
--   
--   Remember that the final type of the result of the do block
--   (<tt>()</tt>, here) must not depend on <tt>n</tt>. However, the
--   
--   Also useful in ghci, where you can pattern match to get sized vectors
--   from unsized vectors.
--   
--   <pre>
--   ghci&gt; SomeSized v &lt;- pure (myUnsizedVector :: Unsized.Vector Int)
--                -- ^ v is `Sized.Vector n Int`
--   </pre>
--   
--   This enables interactive exploration with sized vectors in ghci, and
--   is useful for using with other libraries and functions that expect
--   sized vectors in an interactive setting.
--   
--   (Note that as of GHC 8.6, you cannot get the <tt>n</tt> in scope in
--   your ghci session using ScopedTypeVariables, like you can with do
--   blocks)
--   
--   You can also use this as a constructor, to take a sized vector and
--   "hide" the size, to produce an unsized vector:
--   
--   <pre>
--   SomeSized :: Sized.Vector n a -&gt; Unsized.Vector a
--   </pre>
pattern SomeSized :: Prim a => KnownNat n => Vector n a -> Vector a

-- | <a>Vector</a> specialized to use <a>Mutable</a>.
type MVector = MVector MVector

-- | <i>O(1)</i> Yield the length of the vector as an <a>Int</a>. This is
--   more like <a>natVal</a> than <a>length</a>, extracting the value from
--   the <a>KnownNat</a> instance and not looking at the vector itself.
length :: forall n a. KnownNat n => Vector n a -> Int

-- | <i>O(1)</i> Yield the length of the vector as a <a>Proxy</a>. This
--   function doesn't <i>do</i> anything; it merely allows the size
--   parameter of the vector to be passed around as a <a>Proxy</a>.
length' :: forall n a. Vector n a -> Proxy n

-- | <i>O(1)</i> Reveal a <a>KnownNat</a> instance for a vector's length,
--   determined at runtime.
knownLength :: forall n a r. Prim a => Vector n a -> (KnownNat n => r) -> r

-- | <i>O(1)</i> Reveal a <a>KnownNat</a> instance and <a>Proxy</a> for a
--   vector's length, determined at runtime.
knownLength' :: forall n a r. Prim a => Vector n a -> (KnownNat n => Proxy n -> r) -> r

-- | <i>O(1)</i> Safe indexing using a <a>Finite</a>.
index :: forall n a. Prim a => Vector n a -> Finite n -> a

-- | <i>O(1)</i> Safe indexing using a <a>Proxy</a>.
index' :: forall n m a p. (KnownNat n, Prim a) => Vector ((n + m) + 1) a -> p n -> a

-- | <i>O(1)</i> Indexing using an <a>Int</a> without bounds checking.
unsafeIndex :: forall n a. Prim a => Vector n a -> Int -> a

-- | <i>O(1)</i> Yield the first element of a non-empty vector.
head :: forall n a. Prim a => Vector (1 + n) a -> a

-- | <i>O(1)</i> Yield the last element of a non-empty vector.
last :: forall n a. Prim a => Vector (n + 1) a -> a

-- | <i>O(1)</i> Safe indexing in a monad. See the documentation for
--   <a>indexM</a> for an explanation of why this is useful.
indexM :: forall n a m. (Prim a, Monad m) => Vector n a -> Finite n -> m a

-- | <i>O(1)</i> Safe indexing in a monad using a <a>Proxy</a>. See the
--   documentation for <a>indexM</a> for an explanation of why this is
--   useful.
indexM' :: forall n k a m p. (KnownNat n, Prim a, Monad m) => Vector (n + k) a -> p n -> m a

-- | <i>O(1)</i> Indexing using an <a>Int</a> without bounds checking. See
--   the documentation for <a>indexM</a> for an explanation of why this is
--   useful.
unsafeIndexM :: forall n a m. (Prim a, Monad m) => Vector n a -> Int -> m a

-- | <i>O(1)</i> Yield the first element of a non-empty vector in a monad.
--   See the documentation for <a>indexM</a> for an explanation of why this
--   is useful.
headM :: forall n a m. (Prim a, Monad m) => Vector (1 + n) a -> m a

-- | <i>O(1)</i> Yield the last element of a non-empty vector in a monad.
--   See the documentation for <a>indexM</a> for an explanation of why this
--   is useful.
lastM :: forall n a m. (Prim a, Monad m) => Vector (n + 1) a -> m a

-- | <i>O(1)</i> Yield a slice of the vector without copying it with an
--   inferred length argument.
slice :: forall i n m a p. (KnownNat i, KnownNat n, Prim a) => p i -> Vector ((i + n) + m) a -> Vector n a

-- | <i>O(1)</i> Yield a slice of the vector without copying it with an
--   explicit length argument.
slice' :: forall i n m a p. (KnownNat i, KnownNat n, Prim a) => p i -> p n -> Vector ((i + n) + m) a -> Vector n a

-- | <i>O(1)</i> Yield all but the last element of a non-empty vector
--   without copying.
init :: forall n a. Prim a => Vector (n + 1) a -> Vector n a

-- | <i>O(1)</i> Yield all but the first element of a non-empty vector
--   without copying.
tail :: forall n a. Prim a => Vector (1 + n) a -> Vector n a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is inferred from the type.
take :: forall n m a. (KnownNat n, Prim a) => Vector (n + m) a -> Vector n a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is given explicitly as a <a>Proxy</a> argument.
take' :: forall n m a p. (KnownNat n, Prim a) => p n -> Vector (n + m) a -> Vector n a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is inferred from the type.
drop :: forall n m a. (KnownNat n, Prim a) => Vector (n + m) a -> Vector m a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is givel explicitly as a <a>Proxy</a> argument.
drop' :: forall n m a p. (KnownNat n, Prim a) => p n -> Vector (n + m) a -> Vector m a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The lengths of the resulting vectors are inferred
--   from the type.
splitAt :: forall n m a. (KnownNat n, Prim a) => Vector (n + m) a -> (Vector n a, Vector m a)

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements paired with the
--   remainder without copying. The length of the first resulting vector is
--   passed explicitly as a <a>Proxy</a> argument.
splitAt' :: forall n m a p. (KnownNat n, Prim a) => p n -> Vector (n + m) a -> (Vector n a, Vector m a)

-- | <i>O(1)</i> Empty vector.
empty :: forall a. Prim a => Vector 0 a

-- | <i>O(1)</i> Vector with exactly one element.
singleton :: forall a. Prim a => a -> Vector 1 a

-- | <i>O(n)</i> Construct a vector in a type safe manner <tt> fromTuple
--   (1,2) :: Vector 2 Int fromTuple ("hey", "what's", "going", "on") ::
--   Vector 4 String </tt>
fromTuple :: forall a input length. (Prim a, IndexedListLiterals input length a, KnownNat length) => input -> Vector length a

-- | <i>O(n)</i> Construct a vector with the same element in each position
--   where the length is inferred from the type.
replicate :: forall n a. (KnownNat n, Prim a) => a -> Vector n a

-- | <i>O(n)</i> Construct a vector with the same element in each position
--   where the length is given explicitly as a <a>Proxy</a> argument.
replicate' :: forall n a p. (KnownNat n, Prim a) => p n -> a -> Vector n a

-- | <i>O(n)</i> construct a vector of the given length by applying the
--   function to each index where the length is inferred from the type.
generate :: forall n a. (KnownNat n, Prim a) => (Finite n -> a) -> Vector n a

-- | <i>O(n)</i> construct a vector of the given length by applying the
--   function to each index where the length is given explicitly as a
--   <a>Proxy</a> argument.
generate' :: forall n a p. (KnownNat n, Prim a) => p n -> (Finite n -> a) -> Vector n a

-- | <i>O(n)</i> Apply function <tt>n</tt> times to value. Zeroth element
--   is original value. The length is inferred from the type.
iterateN :: forall n a. (KnownNat n, Prim a) => (a -> a) -> a -> Vector n a

-- | <i>O(n)</i> Apply function <tt>n</tt> times to value. Zeroth element
--   is original value. The length is given explicitly as a <a>Proxy</a>
--   argument.
iterateN' :: forall n a p. (KnownNat n, Prim a) => p n -> (a -> a) -> a -> Vector n a

-- | <i>O(n)</i> Execute the monadic action <tt>n</tt> times and store the
--   results in a vector where <tt>n</tt> is inferred from the type.
replicateM :: forall n m a. (KnownNat n, Prim a, Monad m) => m a -> m (Vector n a)

-- | <i>O(n)</i> Execute the monadic action <tt>n</tt> times and store the
--   results in a vector where <tt>n</tt> is given explicitly as a
--   <a>Proxy</a> argument.
replicateM' :: forall n m a p. (KnownNat n, Prim a, Monad m) => p n -> m a -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector of length <tt>n</tt> by applying the
--   monadic action to each index where <tt>n</tt> is inferred from the
--   type.
generateM :: forall n m a. (KnownNat n, Prim a, Monad m) => (Finite n -> m a) -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector of length <tt>n</tt> by applying the
--   monadic action to each index where <tt>n</tt> is given explicitly as a
--   <a>Proxy</a> argument.
generateM' :: forall n m a p. (KnownNat n, Prim a, Monad m) => p n -> (Finite n -> m a) -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector with exactly <tt>n</tt> elements by
--   repeatedly applying the generator function to the a seed. The length
--   is inferred from the type.
unfoldrN :: forall n a b. (KnownNat n, Prim a) => (b -> (a, b)) -> b -> Vector n a

-- | <i>O(n)</i> Construct a vector with exactly <tt>n</tt> elements by
--   repeatedly applying the generator function to the a seed. The length
--   is given explicitly as a <a>Proxy</a> argument.
unfoldrN' :: forall n a b p. (KnownNat n, Prim a) => p n -> (b -> (a, b)) -> b -> Vector n a

-- | <i>O(n)</i> Yield a vector of length <tt>n</tt> containing the values
--   <tt>x</tt>, <tt>x+1</tt>, ..., <tt>x + (n - 1)</tt>. The length is
--   inferred from the type.
enumFromN :: forall n a. (KnownNat n, Prim a, Num a) => a -> Vector n a

-- | <i>O(n)</i> Yield a vector of length <tt>n</tt> containing the values
--   <tt>x</tt>, <tt>x+1</tt>, ..., <tt>x + (n - 1)</tt>. The length is
--   given explicitly as a <a>Proxy</a> argument.
enumFromN' :: forall n a p. (KnownNat n, Prim a, Num a) => a -> p n -> Vector n a

-- | <i>O(n)</i> Yield a vector of the given length containing the values
--   <tt>x</tt>, <tt>x+y</tt>, <tt>x+2y</tt>, ..., <tt>x + (n - 1)y</tt>.
--   The length is inferred from the type.
enumFromStepN :: forall n a. (KnownNat n, Prim a, Num a) => a -> a -> Vector n a

-- | <i>O(n)</i> Yield a vector of the given length containing the values
--   <tt>x</tt>, <tt>x+y</tt>, <tt>x+2y</tt>, ..., <tt>x + (n - 1)y</tt>.
--   The length is given explicitly as a <a>Proxy</a> argument.
enumFromStepN' :: forall n a p. (KnownNat n, Prim a, Num a) => a -> a -> p n -> Vector n a

-- | <i>O(n)</i> Prepend an element.
cons :: forall n a. Prim a => a -> Vector n a -> Vector (1 + n) a

-- | <i>O(n)</i> Append an element.
snoc :: forall n a. Prim a => Vector n a -> a -> Vector (n + 1) a

-- | <i>O(m+n)</i> Concatenate two vectors.
(++) :: forall n m a. Prim a => Vector n a -> Vector m a -> Vector (n + m) a

-- | <i>O(n)</i> Yield the argument but force it not to retain any extra
--   memory, possibly by copying it.
--   
--   This is especially useful when dealing with slices. For example:
--   
--   <pre>
--   force (slice 0 2 &lt;huge vector&gt;)
--   </pre>
--   
--   Here, the slice retains a reference to the huge vector. Forcing it
--   creates a copy of just the elements that belong to the slice and
--   allows the huge vector to be garbage collected.
force :: Prim a => Vector n a -> Vector n a

-- | <i>O(m+n)</i> For each pair <tt>(i,a)</tt> from the list, replace the
--   vector element at position <tt>i</tt> by <tt>a</tt>.
--   
--   <pre>
--   &lt;5,9,2,7&gt; // [(2,1),(0,3),(2,8)] = &lt;3,9,8,7&gt;
--   </pre>
(//) :: Prim a => Vector m a -> [(Finite m, a)] -> Vector m a

-- | <i>O(m+n)</i> For each index <tt>i</tt> from the index vector and the
--   corresponding value <tt>a</tt> from the value vector, replace the
--   element of the initial vector at position <tt>i</tt> by <tt>a</tt>.
--   
--   <pre>
--   update_ &lt;5,9,2,7&gt;  &lt;2,0,2&gt; &lt;1,3,8&gt; = &lt;3,9,8,7&gt;
--   </pre>
--   
--   This function is useful for instances of <a>Vector</a> that cannot
--   store pairs. Otherwise, <tt>update</tt> is probably more convenient.
--   
--   <pre>
--   update_ xs is ys = <tt>update</tt> xs (<tt>zip</tt> is ys)
--   </pre>
update_ :: Prim a => Vector m a -> Vector n Int -> Vector n a -> Vector m a

-- | Same as (<a>//</a>) but without bounds checking.
unsafeUpd :: Prim a => Vector m a -> [(Int, a)] -> Vector m a

-- | Same as <a>update_</a> but without bounds checking.
unsafeUpdate_ :: Prim a => Vector m a -> Vector n Int -> Vector n a -> Vector m a

-- | <i>O(m+n)</i> For each pair <tt>(i,b)</tt> from the list, replace the
--   vector element <tt>a</tt> at position <tt>i</tt> by <tt>f a b</tt>.
--   
--   <pre>
--   accum (+) &lt;5,9,2&gt; [(2,4),(1,6),(0,3),(1,7)] = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
accum :: Prim a => (a -> b -> a) -> Vector m a -> [(Finite m, b)] -> Vector m a

-- | <i>O(m+n)</i> For each index <tt>i</tt> from the index vector and the
--   corresponding value <tt>b</tt> from the the value vector, replace the
--   element of the initial vector at position <tt>i</tt> by <tt>f a
--   b</tt>.
--   
--   <pre>
--   accumulate_ (+) &lt;5,9,2&gt; &lt;2,1,0,1&gt; &lt;4,6,3,7&gt; = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
--   
--   This function is useful for instances of <a>Vector</a> that cannot
--   store pairs. Otherwise, <tt>accumulate</tt> is probably more
--   convenient:
--   
--   <pre>
--   accumulate_ f as is bs = <tt>accumulate</tt> f as (<tt>zip</tt> is bs)
--   </pre>
accumulate_ :: (Prim a, Prim b) => (a -> b -> a) -> Vector m a -> Vector n Int -> Vector n b -> Vector m a

-- | Same as <a>accum</a> but without bounds checking.
unsafeAccum :: Prim a => (a -> b -> a) -> Vector m a -> [(Int, b)] -> Vector m a

-- | Same as <a>accumulate_</a> but without bounds checking.
unsafeAccumulate_ :: (Prim a, Prim b) => (a -> b -> a) -> Vector m a -> Vector n Int -> Vector n b -> Vector m a

-- | <i>O(n)</i> Reverse a vector.
reverse :: Prim a => Vector n a -> Vector n a

-- | <i>O(n)</i> Yield the vector obtained by replacing each element
--   <tt>i</tt> of the index vector by <tt>xs<tt>!</tt>i</tt>. This is
--   equivalent to <tt><a>map</a> (xs<tt>!</tt>) is</tt> but is often much
--   more efficient.
--   
--   <pre>
--   backpermute &lt;a,b,c,d&gt; &lt;0,3,2,3,1,0&gt; = &lt;a,d,c,d,b,a&gt;
--   </pre>
backpermute :: Prim a => Vector m a -> Vector n Int -> Vector n a

-- | Same as <a>backpermute</a> but without bounds checking.
unsafeBackpermute :: Prim a => Vector m a -> Vector n Int -> Vector n a

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) an arbitrary
--   element by its index.
ix :: forall n a f. (Prim a, Functor f) => Finite n -> (a -> f a) -> Vector n a -> f (Vector n a)

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) the first
--   element of a non-empty vector.
_head :: forall n a f. (Prim a, Functor f) => (a -> f a) -> Vector (1 + n) a -> f (Vector (1 + n) a)

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) the last element
--   of a non-empty vector.
_last :: forall n a f. (Prim a, Functor f) => (a -> f a) -> Vector (n + 1) a -> f (Vector (n + 1) a)

-- | <i>O(n)</i> Map a function over a vector.
map :: (Prim a, Prim b) => (a -> b) -> Vector n a -> Vector n b

-- | <i>O(n)</i> Apply a function to every element of a vector and its
--   index.
imap :: (Prim a, Prim b) => (Finite n -> a -> b) -> Vector n a -> Vector n b

-- | <i>O(n*m)</i> Map a function over a vector and concatenate the
--   results. The function is required to always return the same length
--   vector.
concatMap :: (Prim a, Prim b) => (a -> Vector m b) -> Vector n a -> Vector (n * m) b

-- | <i>O(n)</i> Apply the monadic action to all elements of the vector,
--   yielding a vector of results.
mapM :: (Monad m, Prim a, Prim b) => (a -> m b) -> Vector n a -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to every element of a vector and
--   its index, yielding a vector of results.
imapM :: (Monad m, Prim a, Prim b) => (Finite n -> a -> m b) -> Vector n a -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to all elements of a vector and
--   ignore the results.
mapM_ :: (Monad m, Prim a) => (a -> m b) -> Vector n a -> m ()

-- | <i>O(n)</i> Apply the monadic action to every element of a vector and
--   its index, ignoring the results.
imapM_ :: (Monad m, Prim a) => (Finite n -> a -> m b) -> Vector n a -> m ()

-- | <i>O(n)</i> Apply the monadic action to all elements of the vector,
--   yielding a vector of results. Equvalent to <tt>flip <a>mapM</a></tt>.
forM :: (Monad m, Prim a, Prim b) => Vector n a -> (a -> m b) -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to all elements of a vector and
--   ignore the results. Equivalent to <tt>flip <a>mapM_</a></tt>.
forM_ :: (Monad m, Prim a) => Vector n a -> (a -> m b) -> m ()

-- | <i>O(n)</i> Zip two vectors of the same length with the given
--   function.
zipWith :: (Prim a, Prim b, Prim c) => (a -> b -> c) -> Vector n a -> Vector n b -> Vector n c

-- | Zip three vectors with the given function.
zipWith3 :: (Prim a, Prim b, Prim c, Prim d) => (a -> b -> c -> d) -> Vector n a -> Vector n b -> Vector n c -> Vector n d
zipWith4 :: (Prim a, Prim b, Prim c, Prim d, Prim e) => (a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
zipWith5 :: (Prim a, Prim b, Prim c, Prim d, Prim e, Prim f) => (a -> b -> c -> d -> e -> f) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f
zipWith6 :: (Prim a, Prim b, Prim c, Prim d, Prim e, Prim f, Prim g) => (a -> b -> c -> d -> e -> f -> g) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n g

-- | <i>O(n)</i> Zip two vectors of the same length with a function that
--   also takes the elements' indices).
izipWith :: (Prim a, Prim b, Prim c) => (Finite n -> a -> b -> c) -> Vector n a -> Vector n b -> Vector n c
izipWith3 :: (Prim a, Prim b, Prim c, Prim d) => (Finite n -> a -> b -> c -> d) -> Vector n a -> Vector n b -> Vector n c -> Vector n d
izipWith4 :: (Prim a, Prim b, Prim c, Prim d, Prim e) => (Finite n -> a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
izipWith5 :: (Prim a, Prim b, Prim c, Prim d, Prim e, Prim f) => (Finite n -> a -> b -> c -> d -> e -> f) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f
izipWith6 :: (Prim a, Prim b, Prim c, Prim d, Prim e, Prim f, Prim g) => (Finite n -> a -> b -> c -> d -> e -> f -> g) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n g

-- | <i>O(n)</i> Zip the two vectors of the same length with the monadic
--   action and yield a vector of results.
zipWithM :: (Monad m, Prim a, Prim b, Prim c) => (a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)

-- | <i>O(n)</i> Zip the two vectors with a monadic action that also takes
--   the element index and yield a vector of results.
izipWithM :: (Monad m, Prim a, Prim b, Prim c) => (Finite n -> a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)

-- | <i>O(n)</i> Zip the two vectors with the monadic action and ignore the
--   results.
zipWithM_ :: (Monad m, Prim a, Prim b) => (a -> b -> m c) -> Vector n a -> Vector n b -> m ()

-- | <i>O(n)</i> Zip the two vectors with a monadic action that also takes
--   the element index and ignore the results.
izipWithM_ :: (Monad m, Prim a, Prim b) => (Finite n -> a -> b -> m c) -> Vector n a -> Vector n b -> m ()

-- | <i>O(n)</i> Check if the vector contains an element.
elem :: (Prim a, Eq a) => a -> Vector n a -> Bool
infix 4 `elem`

-- | <i>O(n)</i> Check if the vector does not contain an element (inverse
--   of <a>elem</a>).
notElem :: (Prim a, Eq a) => a -> Vector n a -> Bool
infix 4 `notElem`

-- | <i>O(n)</i> Yield <a>Just</a> the first element matching the predicate
--   or <a>Nothing</a> if no such element exists.
find :: Prim a => (a -> Bool) -> Vector n a -> Maybe a

-- | <i>O(n)</i> Yield <a>Just</a> the index of the first element matching
--   the predicate or <a>Nothing</a> if no such element exists.
findIndex :: Prim a => (a -> Bool) -> Vector n a -> Maybe (Finite n)

-- | <i>O(n)</i> Yield <a>Just</a> the index of the first occurence of the
--   given element or <a>Nothing</a> if the vector does not contain the
--   element. This is a specialised version of <a>findIndex</a>.
elemIndex :: (Prim a, Eq a) => a -> Vector n a -> Maybe (Finite n)

-- | <i>O(n)</i> Left fold.
foldl :: Prim b => (a -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold on non-empty vectors.
foldl1 :: Prim a => (a -> a -> a) -> Vector (1 + n) a -> a

-- | <i>O(n)</i> Left fold with strict accumulator.
foldl' :: Prim b => (a -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold on non-empty vectors with strict accumulator.
foldl1' :: Prim a => (a -> a -> a) -> Vector (1 + n) a -> a

-- | <i>O(n)</i> Right fold.
foldr :: Prim a => (a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold on non-empty vectors.
foldr1 :: Prim a => (a -> a -> a) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Right fold with a strict accumulator.
foldr' :: Prim a => (a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold on non-empty vectors with strict accumulator.
foldr1' :: Prim a => (a -> a -> a) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Left fold (function applied to each element and its
--   index).
ifoldl :: Prim b => (a -> Finite n -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold with strict accumulator (function applied to
--   each element and its index).
ifoldl' :: Prim b => (a -> Finite n -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Right fold (function applied to each element and its
--   index).
ifoldr :: Prim a => (Finite n -> a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold with strict accumulator (function applied to
--   each element and its index).
ifoldr' :: Prim a => (Finite n -> a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Check if all elements satisfy the predicate.
all :: Prim a => (a -> Bool) -> Vector n a -> Bool

-- | <i>O(n)</i> Check if any element satisfies the predicate.
any :: Prim a => (a -> Bool) -> Vector n a -> Bool

-- | <i>O(n)</i> Compute the sum of the elements.
sum :: (Prim a, Num a) => Vector n a -> a

-- | <i>O(n)</i> Compute the product of the elements.
product :: (Prim a, Num a) => Vector n a -> a

-- | <i>O(n)</i> Yield the maximum element of the non-empty vector.
maximum :: (Prim a, Ord a) => Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the maximum element of the non-empty vector
--   according to the given comparison function.
maximumBy :: Prim a => (a -> a -> Ordering) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the minimum element of the non-empty vector.
minimum :: (Prim a, Ord a) => Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the minimum element of the non-empty vector
--   according to the given comparison function.
minimumBy :: Prim a => (a -> a -> Ordering) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the index of the maximum element of the non-empty
--   vector.
maxIndex :: (Prim a, Ord a) => Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the maximum element of the non-empty
--   vector according to the given comparison function.
maxIndexBy :: Prim a => (a -> a -> Ordering) -> Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the minimum element of the non-empty
--   vector.
minIndex :: (Prim a, Ord a) => Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the minimum element of the non-empty
--   vector according to the given comparison function.
minIndexBy :: Prim a => (a -> a -> Ordering) -> Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Monadic fold.
foldM :: (Monad m, Prim b) => (a -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold (action applied to each element and its
--   index).
ifoldM :: (Monad m, Prim b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold over non-empty vectors.
fold1M :: (Monad m, Prim a) => (a -> a -> m a) -> Vector (1 + n) a -> m a

-- | <i>O(n)</i> Monadic fold with strict accumulator.
foldM' :: (Monad m, Prim b) => (a -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold with strict accumulator (action applied to
--   each element and its index).
ifoldM' :: (Monad m, Prim b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold over non-empty vectors with strict
--   accumulator.
fold1M' :: (Monad m, Prim a) => (a -> a -> m a) -> Vector (n + 1) a -> m a

-- | <i>O(n)</i> Monadic fold that discards the result.
foldM_ :: (Monad m, Prim b) => (a -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold that discards the result (action applied to
--   each element and its index).
ifoldM_ :: (Monad m, Prim b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold over non-empty vectors that discards the
--   result.
fold1M_ :: (Monad m, Prim a) => (a -> a -> m a) -> Vector (n + 1) a -> m ()

-- | <i>O(n)</i> Monadic fold with strict accumulator that discards the
--   result.
foldM'_ :: (Monad m, Prim b) => (a -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold with strict accumulator that discards the
--   result (action applied to each element and its index).
ifoldM'_ :: (Monad m, Prim b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monad fold over non-empty vectors with strict accumulator
--   that discards the result.
fold1M'_ :: (Monad m, Prim a) => (a -> a -> m a) -> Vector (n + 1) a -> m ()

-- | <i>O(n)</i> Prescan.
--   
--   <pre>
--   prescanl f z = <a>init</a> . <a>scanl</a> f z
--   </pre>
--   
--   Example: <tt>prescanl (+) 0 &lt;1,2,3,4&gt; = &lt;0,1,3,6&gt;</tt>
prescanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Prescan with strict accumulator.
prescanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Scan.
postscanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Scan with strict accumulator.
postscanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Haskell-style scan.
scanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector n b -> Vector (1 + n) a

-- | <i>O(n)</i> Haskell-style scan with strict accumulator.
scanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector n b -> Vector (1 + n) a

-- | <i>O(n)</i> Scan over a non-empty vector.
scanl1 :: Prim a => (a -> a -> a) -> Vector (1 + n) a -> Vector (2 + n) a

-- | <i>O(n)</i> Scan over a non-empty vector with a strict accumulator.
scanl1' :: Prim a => (a -> a -> a) -> Vector (1 + n) a -> Vector (2 + n) a

-- | <i>O(n)</i> Right-to-left prescan.
prescanr :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left prescan with strict accumulator.
prescanr' :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left scan.
postscanr :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left scan with strict accumulator.
postscanr' :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left Haskell-style scan.
scanr :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector n a -> Vector (n + 1) b

-- | <i>O(n)</i> Right-to-left Haskell-style scan with strict accumulator.
scanr' :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector n a -> Vector (n + 1) b

-- | <i>O(n)</i> Right-to-left scan over a non-empty vector.
scanr1 :: Prim a => (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 2) a

-- | <i>O(n)</i> Right-to-left scan over a non-empty vector with a strict
--   accumulator.
scanr1' :: Prim a => (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 2) a

-- | <i>O(n)</i> Convert a vector to a list.
toList :: Prim a => Vector n a -> [a]

-- | <i>O(n)</i> Convert a list to a vector.
fromList :: (Prim a, KnownNat n) => [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Convert the first <tt>n</tt> elements of a list to a
--   vector. The length of the resulting vector is inferred from the type.
fromListN :: forall n a. (Prim a, KnownNat n) => [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Convert the first <tt>n</tt> elements of a list to a
--   vector. The length of the resulting vector is given explicitly as a
--   <a>Proxy</a> argument.
fromListN' :: forall n a p. (Prim a, KnownNat n) => p n -> [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Takes a list and returns a continuation providing a vector
--   with a size parameter corresponding to the length of the list.
--   
--   Essentially converts a list into a vector with the proper size
--   parameter, determined at runtime.
--   
--   See <a>withSized</a>
withSizedList :: forall a r. Prim a => [a] -> (forall n. KnownNat n => Vector n a -> r) -> r

-- | <i>O(n)</i> Yield an immutable copy of the mutable vector.
freeze :: (PrimMonad m, Prim a) => MVector n (PrimState m) a -> m (Vector n a)

-- | <i>O(n)</i> Yield a mutable copy of the immutable vector.
thaw :: (PrimMonad m, Prim a) => Vector n a -> m (MVector n (PrimState m) a)

-- | <i>O(n)</i> Copy an immutable vector into a mutable one.
copy :: (PrimMonad m, Prim a) => MVector n (PrimState m) a -> Vector n a -> m ()

-- | <i>O(1)</i> Unsafely convert a mutable vector to an immutable one
--   withouy copying. The mutable vector may not be used after this
--   operation.
unsafeFreeze :: (PrimMonad m, Prim a) => MVector n (PrimState m) a -> m (Vector n a)

-- | <i>O(n)</i> Unsafely convert an immutable vector to a mutable one
--   without copying. The immutable vector may not be used after this
--   operation.
unsafeThaw :: (PrimMonad m, Prim a) => Vector n a -> m (MVector n (PrimState m) a)

-- | Convert a <a>Vector</a> into a <a>Vector</a> if it has the correct
--   size, otherwise return <a>Nothing</a>.
toSized :: forall n a. (Prim a, KnownNat n) => Vector a -> Maybe (Vector n a)

-- | Takes a <a>Vector</a> and returns a continuation providing a
--   <a>Vector</a> with a size parameter <tt>n</tt> that is determined at
--   runtime based on the length of the input vector.
--   
--   Essentially converts a <a>Vector</a> into a <a>Vector</a> with the
--   correct size parameter <tt>n</tt>.
withSized :: forall a r. Prim a => Vector a -> (forall n. KnownNat n => Vector n a -> r) -> r
fromSized :: Vector n a -> Vector a

-- | Apply a function on unsized vectors to a sized vector. The function
--   must preserve the size of the vector, this is not checked.
withVectorUnsafe :: forall a b (n :: Nat). () => (Vector a -> Vector b) -> Vector n a -> Vector n b


-- | This module re-exports the functionality in <a>Sized</a> specialized
--   to <a>Vector</a>.
--   
--   Functions returning a vector determine the size from the type context
--   unless they have a <tt>'</tt> suffix in which case they take an
--   explicit <a>Proxy</a> argument.
--   
--   Functions where the resulting vector size is not known until runtime
--   are not exported.
module Data.Vector.Sized

-- | <a>Vector</a> specialized to use <a>Vector</a>.
type Vector = Vector Vector

-- | Pattern synonym that lets you treat an unsized vector as if it
--   "contained" a sized vector. If you pattern match on an unsized vector,
--   its contents will be the <i>sized</i> vector counterpart.
--   
--   <pre>
--   testFunc :: Unsized.Vector Int -&gt; Int
--   testFunc (<a>SomeSized</a> v) =
--       <a>sum</a> (<a>zipWith</a> (+) v (<a>replicate</a> 1))
--           -- ^ here, v is `Sized.Vector n Int`, and we have
--                       `<a>KnownNat</a> n`
--   </pre>
--   
--   The <tt>n</tt> type variable will be properly instantiated to whatever
--   the length of the vector is, and you will also have a
--   <tt><a>KnownNat</a> n</tt> instance available. You can get <tt>n</tt>
--   in scope by turning on ScopedTypeVariables and matching on
--   <tt><a>SomeSized</a> (v :: Sized.Vector n Int)</tt>.
--   
--   Without this, you would otherwise have to use <a>withSized</a> to do
--   the same thing:
--   
--   <pre>
--   testFunc :: Unsized.Vector Int -&gt; Int
--   testFunc u = <a>withSized</a> u $ \v -&gt;
--       <a>sum</a> (<a>zipWith</a> (+) v (<a>replicate</a> 1))
--   </pre>
--   
--   Remember that the type of final result of your function (the
--   <tt>Int</tt>, here) must <i>not</i> depend on <tt>n</tt>. However, the
--   types of the intermediate values are allowed to depend on <tt>n</tt>.
--   
--   This is <i>especially</i> useful in do blocks, where you can pattern
--   match on the unsized results of actions, to use the sized vector in
--   the rest of the do block. You also get a <tt><a>KnownNat</a> n</tt>
--   constraint for the remainder of the do block.
--   
--   <pre>
--   -- If you had:
--   getAVector :: IO (Unsized.Vector Int)
--   
--   main :: IO ()
--   main = do
--       SomeSized v &lt;- getAVector -- v is `Sized.Vector n Int`
--       -- get n in scope
--       SomeSized (v :: Sized.Vector n Int) &lt;- getAVector
--       print v
--   </pre>
--   
--   Remember that the final type of the result of the do block
--   (<tt>()</tt>, here) must not depend on <tt>n</tt>. However, the
--   
--   Also useful in ghci, where you can pattern match to get sized vectors
--   from unsized vectors.
--   
--   <pre>
--   ghci&gt; SomeSized v &lt;- pure (myUnsizedVector :: Unsized.Vector Int)
--                -- ^ v is `Sized.Vector n Int`
--   </pre>
--   
--   This enables interactive exploration with sized vectors in ghci, and
--   is useful for using with other libraries and functions that expect
--   sized vectors in an interactive setting.
--   
--   (Note that as of GHC 8.6, you cannot get the <tt>n</tt> in scope in
--   your ghci session using ScopedTypeVariables, like you can with do
--   blocks)
--   
--   You can also use this as a constructor, to take a sized vector and
--   "hide" the size, to produce an unsized vector:
--   
--   <pre>
--   SomeSized :: Sized.Vector n a -&gt; Unsized.Vector a
--   </pre>
pattern SomeSized :: () => KnownNat n => Vector n a -> Vector a

-- | <a>Vector</a> specialized to use <a>Mutable</a>.
type MVector = MVector MVector

-- | <i>O(1)</i> Yield the length of the vector as an <a>Int</a>. This is
--   more like <a>natVal</a> than <a>length</a>, extracting the value from
--   the <a>KnownNat</a> instance and not looking at the vector itself.
length :: forall n a. KnownNat n => Vector n a -> Int

-- | <i>O(1)</i> Yield the length of the vector as a <a>Proxy</a>. This
--   function doesn't <i>do</i> anything; it merely allows the size
--   parameter of the vector to be passed around as a <a>Proxy</a>.
length' :: forall n a. Vector n a -> Proxy n

-- | <i>O(1)</i> Reveal a <a>KnownNat</a> instance for a vector's length,
--   determined at runtime.
knownLength :: forall n a r. Vector n a -> (KnownNat n => r) -> r

-- | <i>O(1)</i> Reveal a <a>KnownNat</a> instance and <a>Proxy</a> for a
--   vector's length, determined at runtime.
knownLength' :: forall n a r. Vector n a -> (KnownNat n => Proxy n -> r) -> r

-- | <i>O(1)</i> Safe indexing using a <a>Finite</a>.
index :: forall n a. () => Vector n a -> Finite n -> a

-- | <i>O(1)</i> Safe indexing using a <a>Proxy</a>.
index' :: forall n m a p. KnownNat n => Vector ((n + m) + 1) a -> p n -> a

-- | <i>O(1)</i> Indexing using an <a>Int</a> without bounds checking.
unsafeIndex :: forall n a. () => Vector n a -> Int -> a

-- | <i>O(1)</i> Yield the first element of a non-empty vector.
head :: forall n a. Vector (1 + n) a -> a

-- | <i>O(1)</i> Yield the last element of a non-empty vector.
last :: forall n a. Vector (n + 1) a -> a

-- | <i>O(1)</i> Safe indexing in a monad. See the documentation for
--   <a>indexM</a> for an explanation of why this is useful.
indexM :: forall n a m. Monad m => Vector n a -> Finite n -> m a

-- | <i>O(1)</i> Safe indexing in a monad using a <a>Proxy</a>. See the
--   documentation for <a>indexM</a> for an explanation of why this is
--   useful.
indexM' :: forall n k a m p. (KnownNat n, Monad m) => Vector (n + k) a -> p n -> m a

-- | <i>O(1)</i> Indexing using an Int without bounds checking. See the
--   documentation for <a>indexM</a> for an explanation of why this is
--   useful.
unsafeIndexM :: forall n a m. Monad m => Vector n a -> Int -> m a

-- | <i>O(1)</i> Yield the first element of a non-empty vector in a monad.
--   See the documentation for <a>indexM</a> for an explanation of why this
--   is useful.
headM :: forall n a m. Monad m => Vector (1 + n) a -> m a

-- | <i>O(1)</i> Yield the last element of a non-empty vector in a monad.
--   See the documentation for <a>indexM</a> for an explanation of why this
--   is useful.
lastM :: forall n a m. Monad m => Vector (n + 1) a -> m a

-- | <i>O(1)</i> Yield a slice of the vector without copying it with an
--   inferred length argument.
slice :: forall i n m a p. (KnownNat i, KnownNat n) => p i -> Vector ((i + n) + m) a -> Vector n a

-- | <i>O(1)</i> Yield a slice of the vector without copying it with an
--   explicit length argument.
slice' :: forall i n m a p. (KnownNat i, KnownNat n) => p i -> p n -> Vector ((i + n) + m) a -> Vector n a

-- | <i>O(1)</i> Yield all but the last element of a non-empty vector
--   without copying.
init :: forall n a. Vector (n + 1) a -> Vector n a

-- | <i>O(1)</i> Yield all but the first element of a non-empty vector
--   without copying.
tail :: forall n a. Vector (1 + n) a -> Vector n a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is inferred from the type.
take :: forall n m a. KnownNat n => Vector (n + m) a -> Vector n a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is given explicitly as a <a>Proxy</a> argument.
take' :: forall n m a p. KnownNat n => p n -> Vector (n + m) a -> Vector n a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is inferred from the type.
drop :: forall n m a. KnownNat n => Vector (n + m) a -> Vector m a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is givel explicitly as a <a>Proxy</a> argument.
drop' :: forall n m a p. KnownNat n => p n -> Vector (n + m) a -> Vector m a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements paired with the
--   remainder without copying. The lengths of the resulting vectors are
--   inferred from the type.
splitAt :: forall n m a. KnownNat n => Vector (n + m) a -> (Vector n a, Vector m a)

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The length of the first resulting vector is passed
--   explicitly as a <a>Proxy</a> argument.
splitAt' :: forall n m a p. KnownNat n => p n -> Vector (n + m) a -> (Vector n a, Vector m a)

-- | <i>O(1)</i> Empty vector.
empty :: forall a. Vector 0 a

-- | <i>O(1)</i> Vector with exactly one element.
singleton :: forall a. a -> Vector 1 a

-- | <i>O(n)</i> Construct a vector in a type safe manner. <tt> fromTuple
--   (1,2) :: Vector 2 Int fromTuple ("hey", "what's", "going", "on") ::
--   Vector 4 String </tt>
fromTuple :: forall input length ty. (IndexedListLiterals input length ty, KnownNat length) => input -> Vector length ty

-- | <i>O(n)</i> Construct a vector with the same element in each position
--   where the length is inferred from the type.
replicate :: forall n a. KnownNat n => a -> Vector n a

-- | <i>O(n)</i> Construct a vector with the same element in each position
--   where the length is given explicitly as a <a>Proxy</a> argument.
replicate' :: forall n a p. KnownNat n => p n -> a -> Vector n a

-- | <i>O(n)</i> construct a vector of the given length by applying the
--   function to each index where the length is inferred from the type.
generate :: forall n a. KnownNat n => (Finite n -> a) -> Vector n a

-- | <i>O(n)</i> construct a vector of the given length by applying the
--   function to each index where the length is given explicitly as a
--   <a>Proxy</a> argument.
generate' :: forall n a p. KnownNat n => p n -> (Finite n -> a) -> Vector n a

-- | <i>O(n)</i> Apply the function <tt>n</tt> times to a value. Zeroth
--   element is original value. The length is inferred from the type.
iterateN :: forall n a. KnownNat n => (a -> a) -> a -> Vector n a

-- | <i>O(n)</i> Apply the function <tt>n</tt> times to a value. Zeroth
--   element is original value. The length is given explicitly as a
--   <a>Proxy</a> argument.
iterateN' :: forall n a p. KnownNat n => p n -> (a -> a) -> a -> Vector n a

-- | <i>O(n)</i> Execute the monadic action <tt>n</tt> times and store the
--   results in a vector where <tt>n</tt> is inferred from the type.
replicateM :: forall n m a. (KnownNat n, Monad m) => m a -> m (Vector n a)

-- | <i>O(n)</i> Execute the monadic action <tt>n</tt> times and store the
--   results in a vector where <tt>n</tt> is given explicitly as a
--   <a>Proxy</a> argument.
replicateM' :: forall n m a p. (KnownNat n, Monad m) => p n -> m a -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector of length <tt>n</tt> by applying the
--   monadic action to each index where n is inferred from the type.
generateM :: forall n m a. (KnownNat n, Monad m) => (Finite n -> m a) -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector of length <tt>n</tt> by applying the
--   monadic action to each index where n is given explicitly as a
--   <a>Proxy</a> argument.
generateM' :: forall n m a p. (KnownNat n, Monad m) => p n -> (Finite n -> m a) -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector with exactly <tt>n</tt> elements by
--   repeatedly applying the generator function to the a seed. The length
--   is inferred from the type.
unfoldrN :: forall n a b. KnownNat n => (b -> (a, b)) -> b -> Vector n a

-- | <i>O(n)</i> Construct a vector with exactly <tt>n</tt> elements by
--   repeatedly applying the generator function to the a seed. The length
--   is given explicitly as a <a>Proxy</a> argument.
unfoldrN' :: forall n a b p. KnownNat n => p n -> (b -> (a, b)) -> b -> Vector n a

-- | <i>O(n)</i> Yield a vector of length <tt>n</tt> containing the values
--   <tt>x</tt>, <tt>x+1</tt>, ..., <tt>x + (n - 1)</tt>. The length is
--   inferred from the type.
enumFromN :: forall n a. (KnownNat n, Num a) => a -> Vector n a

-- | <i>O(n)</i> Yield a vector of length <tt>n</tt> containing the values
--   <tt>x</tt>, <tt>x+1</tt>, ..., <tt>x + (n - 1)</tt>. The length is
--   given explicitly as a <a>Proxy</a> argument.
enumFromN' :: forall n a p. (KnownNat n, Num a) => a -> p n -> Vector n a

-- | <i>O(n)</i> Yield a vector of the given length containing the values
--   <tt>x</tt>, <tt>x+y</tt>, <tt>x+2y</tt>, ... , <tt>x + (n - 1)y</tt>.
--   The length is inferred from the type.
enumFromStepN :: forall n a. (KnownNat n, Num a) => a -> a -> Vector n a

-- | <i>O(n)</i> Yield a vector of the given length containing the values
--   <tt>x</tt>, <tt>x+y</tt>, <tt>x+2y</tt>, ... , <tt>x + (n - 1)y</tt>.
--   The length is given explicitly as a <a>Proxy</a> argument.
enumFromStepN' :: forall n a p. (KnownNat n, Num a) => a -> a -> p n -> Vector n a

-- | <i>O(n)</i> Prepend an element.
cons :: forall n a. a -> Vector n a -> Vector (1 + n) a

-- | <i>O(n)</i> Append an element.
snoc :: forall n a. Vector n a -> a -> Vector (n + 1) a

-- | <i>O(m+n)</i> Concatenate two vectors.
(++) :: forall n m a. Vector n a -> Vector m a -> Vector (n + m) a

-- | <i>O(n)</i> Yield the argument but force it not to retain any extra
--   memory, possibly by copying it.
--   
--   This is especially useful when dealing with slices. For example:
--   
--   <pre>
--   force (slice 0 2 &lt;huge vector&gt;)
--   </pre>
--   
--   Here, the slice retains a reference to the huge vector. Forcing it
--   creates a copy of just the elements that belong to the slice and
--   allows the huge vector to be garbage collected.
force :: Vector n a -> Vector n a

-- | <i>O(m+n)</i> For each pair <tt>(i,a)</tt> from the list, replace the
--   vector element at position <tt>i</tt> by <tt>a</tt>.
--   
--   <pre>
--   &lt;5,9,2,7&gt; // [(2,1),(0,3),(2,8)] = &lt;3,9,8,7&gt;
--   </pre>
(//) :: Vector m a -> [(Finite m, a)] -> Vector m a

-- | <i>O(m+n)</i> For each pair <tt>(i,a)</tt> from the vector of
--   index/value pairs, replace the vector element at position <tt>i</tt>
--   by <tt>a</tt>.
--   
--   <pre>
--   update &lt;5,9,2,7&gt; &lt;(2,1),(0,3),(2,8)&gt; = &lt;3,9,8,7&gt;
--   </pre>
update :: Vector m a -> Vector n (Int, a) -> Vector m a

-- | <i>O(m+n)</i> For each index <tt>i</tt> from the index vector and the
--   corresponding value <tt>a</tt> from the value vector, replace the
--   element of the initial vector at position <tt>i</tt> by <tt>a</tt>.
--   
--   <pre>
--   update_ &lt;5,9,2,7&gt;  &lt;2,0,2&gt; &lt;1,3,8&gt; = &lt;3,9,8,7&gt;
--   </pre>
--   
--   This function is useful for instances of <a>Vector</a> that cannot
--   store pairs. Otherwise, <a>update</a> is probably more convenient.
--   
--   <pre>
--   update_ xs is ys = <a>update</a> xs (<a>zip</a> is ys)
--   </pre>
update_ :: Vector m a -> Vector n Int -> Vector n a -> Vector m a

-- | Same as (<a>//</a>) but without bounds checking.
unsafeUpd :: Vector m a -> [(Int, a)] -> Vector m a

-- | Same as <a>update</a> but without bounds checking.
unsafeUpdate :: Vector m a -> Vector n (Int, a) -> Vector m a

-- | Same as <a>update_</a> but without bounds checking.
unsafeUpdate_ :: Vector m a -> Vector n Int -> Vector n a -> Vector m a

-- | <i>O(m+n)</i> For each pair <tt>(i,b)</tt> from the list, replace the
--   vector element <tt>a</tt> at position <tt>i</tt> by <tt>f a b</tt>.
--   
--   <pre>
--   accum (+) &lt;5,9,2&gt; [(2,4),(1,6),(0,3),(1,7)] = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
accum :: (a -> b -> a) -> Vector m a -> [(Finite m, b)] -> Vector m a

-- | <i>O(m+n)</i> For each pair <tt>(i,b)</tt> from the vector of pairs,
--   replace the vector element <tt>a</tt> at position <tt>i</tt> by <tt>f
--   a b</tt>.
--   
--   <pre>
--   accumulate (+) &lt;5,9,2&gt; &lt;(2,4),(1,6),(0,3),(1,7)&gt; = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
accumulate :: (a -> b -> a) -> Vector m a -> Vector n (Int, b) -> Vector m a

-- | <i>O(m+n)</i> For each index <tt>i</tt> from the index vector and the
--   corresponding value <tt>b</tt> from the the value vector, replace the
--   element of the initial vector at position <tt>i</tt> by <tt>f a
--   b</tt>.
--   
--   <pre>
--   accumulate_ (+) &lt;5,9,2&gt; &lt;2,1,0,1&gt; &lt;4,6,3,7&gt; = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
--   
--   This function is useful for instances of <a>Vector</a> that cannot
--   store pairs. Otherwise, <a>accumulate</a> is probably more convenient:
--   
--   <pre>
--   accumulate_ f as is bs = <a>accumulate</a> f as (<a>zip</a> is bs)
--   </pre>
accumulate_ :: (a -> b -> a) -> Vector m a -> Vector n Int -> Vector n b -> Vector m a

-- | Same as <a>accum</a> but without bounds checking.
unsafeAccum :: (a -> b -> a) -> Vector m a -> [(Int, b)] -> Vector m a

-- | Same as <a>accumulate</a> but without bounds checking.
unsafeAccumulate :: (a -> b -> a) -> Vector m a -> Vector n (Int, b) -> Vector m a

-- | Same as <a>accumulate_</a> but without bounds checking.
unsafeAccumulate_ :: (a -> b -> a) -> Vector m a -> Vector n Int -> Vector n b -> Vector m a

-- | <i>O(n)</i> Reverse a vector.
reverse :: Vector n a -> Vector n a

-- | <i>O(n)</i> Yield the vector obtained by replacing each element
--   <tt>i</tt> of the index vector by <tt>xs<tt>!</tt>i</tt>. This is
--   equivalent to <tt><a>map</a> (xs<tt>!</tt>) is</tt> but is often much
--   more efficient.
--   
--   <pre>
--   backpermute &lt;a,b,c,d&gt; &lt;0,3,2,3,1,0&gt; = &lt;a,d,c,d,b,a&gt;
--   </pre>
backpermute :: Vector m a -> Vector n Int -> Vector n a

-- | Same as <a>backpermute</a> but without bounds checking.
unsafeBackpermute :: Vector m a -> Vector n Int -> Vector n a

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) an arbitrary
--   element by its index.
ix :: forall n a f. Functor f => Finite n -> (a -> f a) -> Vector n a -> f (Vector n a)

-- | Type-safe lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) an
--   arbitrary element by its index which should be supplied via
--   TypeApplications.
ix' :: forall i n a f. (Functor f, KnownNat i, KnownNat n, (i + 1) <= n) => (a -> f a) -> Vector n a -> f (Vector n a)

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) the first
--   element of a non-empty vector.
_head :: forall n a f. Functor f => (a -> f a) -> Vector (1 + n) a -> f (Vector (1 + n) a)

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) the last element
--   of a non-empty vector.
_last :: forall n a f. Functor f => (a -> f a) -> Vector (n + 1) a -> f (Vector (n + 1) a)

-- | <i>O(n)</i> Pair each element in a vector with its index.
indexed :: Vector n a -> Vector n (Finite n, a)

-- | <i>O(n)</i> Map a function over a vector.
map :: (a -> b) -> Vector n a -> Vector n b

-- | <i>O(n)</i> Apply a function to every element of a vector and its
--   index.
imap :: (Finite n -> a -> b) -> Vector n a -> Vector n b

-- | <i>O(n*m)</i> Map a function over a vector and concatenate the
--   results. The function is required to always return the same length
--   vector.
concatMap :: (a -> Vector m b) -> Vector n a -> Vector (n * m) b

-- | <i>O(n)</i> Apply the monadic action to all elements of the vector,
--   yielding a vector of results.
mapM :: Monad m => (a -> m b) -> Vector n a -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to every element of a vector and
--   its index, yielding a vector of results.
imapM :: Monad m => (Finite n -> a -> m b) -> Vector n a -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to all elements of a vector and
--   ignore the results.
mapM_ :: Monad m => (a -> m b) -> Vector n a -> m ()

-- | <i>O(n)</i> Apply the monadic action to every element of a vector and
--   its index, ignoring the results.
imapM_ :: Monad m => (Finite n -> a -> m b) -> Vector n a -> m ()

-- | <i>O(n)</i> Apply the monadic action to all elements of the vector,
--   yielding a vector of results. Equvalent to <tt>flip <a>mapM</a></tt>.
forM :: Monad m => Vector n a -> (a -> m b) -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to all elements of a vector and
--   ignore the results. Equivalent to <tt>flip <a>mapM_</a></tt>.
forM_ :: Monad m => Vector n a -> (a -> m b) -> m ()

-- | <i>O(n)</i> Zip two vectors of the same length with the given
--   function.
zipWith :: (a -> b -> c) -> Vector n a -> Vector n b -> Vector n c

-- | Zip three vectors with the given function.
zipWith3 :: (a -> b -> c -> d) -> Vector n a -> Vector n b -> Vector n c -> Vector n d
zipWith4 :: (a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
zipWith5 :: (a -> b -> c -> d -> e -> f) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f
zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n g

-- | <i>O(n)</i> Zip two vectors of the same length with a function that
--   also takes the elements' indices).
izipWith :: (Finite n -> a -> b -> c) -> Vector n a -> Vector n b -> Vector n c
izipWith3 :: (Finite n -> a -> b -> c -> d) -> Vector n a -> Vector n b -> Vector n c -> Vector n d
izipWith4 :: (Finite n -> a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
izipWith5 :: (Finite n -> a -> b -> c -> d -> e -> f) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f
izipWith6 :: (Finite n -> a -> b -> c -> d -> e -> f -> g) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n g

-- | <i>O(n)</i> Zip two vectors of the same length.
zip :: Vector n a -> Vector n b -> Vector n (a, b)
zip3 :: Vector n a -> Vector n b -> Vector n c -> Vector n (a, b, c)
zip4 :: Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n (a, b, c, d)
zip5 :: Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n (a, b, c, d, e)
zip6 :: Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n (a, b, c, d, e, f)

-- | <i>O(n)</i> Zip the two vectors of the same length with the monadic
--   action and yield a vector of results.
zipWithM :: Monad m => (a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)

-- | <i>O(n)</i> Zip the two vectors with a monadic action that also takes
--   the element index and yield a vector of results.
izipWithM :: Monad m => (Finite n -> a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)

-- | <i>O(n)</i> Zip the two vectors with the monadic action and ignore the
--   results.
zipWithM_ :: Monad m => (a -> b -> m c) -> Vector n a -> Vector n b -> m ()

-- | <i>O(n)</i> Zip the two vectors with a monadic action that also takes
--   the element index and ignore the results.
izipWithM_ :: Monad m => (Finite n -> a -> b -> m c) -> Vector n a -> Vector n b -> m ()

-- | <i>O(min(m,n))</i> Unzip a vector of pairs.
unzip :: Vector n (a, b) -> (Vector n a, Vector n b)
unzip3 :: Vector n (a, b, c) -> (Vector n a, Vector n b, Vector n c)
unzip4 :: Vector n (a, b, c, d) -> (Vector n a, Vector n b, Vector n c, Vector n d)
unzip5 :: Vector n (a, b, c, d, e) -> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e)
unzip6 :: Vector n (a, b, c, d, e, f) -> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e, Vector n f)

-- | <i>O(n)</i> Check if the vector contains an element.
elem :: Eq a => a -> Vector n a -> Bool
infix 4 `elem`

-- | <i>O(n)</i> Check if the vector does not contain an element (inverse
--   of <a>elem</a>).
notElem :: Eq a => a -> Vector n a -> Bool
infix 4 `notElem`

-- | <i>O(n)</i> Yield <a>Just</a> the first element matching the predicate
--   or <a>Nothing</a> if no such element exists.
find :: (a -> Bool) -> Vector n a -> Maybe a

-- | <i>O(n)</i> Yield <a>Just</a> the index of the first element matching
--   the predicate or <a>Nothing</a> if no such element exists.
findIndex :: (a -> Bool) -> Vector n a -> Maybe (Finite n)

-- | <i>O(n)</i> Yield <a>Just</a> the index of the first occurence of the
--   given element or <a>Nothing</a> if the vector does not contain the
--   element. This is a specialised version of <a>findIndex</a>.
elemIndex :: Eq a => a -> Vector n a -> Maybe (Finite n)

-- | <i>O(n)</i> Left fold.
foldl :: (a -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold on non-empty vectors.
foldl1 :: (a -> a -> a) -> Vector (1 + n) a -> a

-- | <i>O(n)</i> Left fold with strict accumulator.
foldl' :: (a -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold on non-empty vectors with strict accumulator.
foldl1' :: (a -> a -> a) -> Vector (1 + n) a -> a

-- | <i>O(n)</i> Right fold.
foldr :: (a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold on non-empty vectors.
foldr1 :: (a -> a -> a) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Right fold with a strict accumulator.
foldr' :: (a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold on non-empty vectors with strict accumulator.
foldr1' :: (a -> a -> a) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Left fold (function applied to each element and its
--   index).
ifoldl :: (a -> Finite n -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold with strict accumulator (function applied to
--   each element and its index).
ifoldl' :: (a -> Finite n -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Right fold (function applied to each element and its
--   index).
ifoldr :: (Finite n -> a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold with strict accumulator (function applied to
--   each element and its index).
ifoldr' :: (Finite n -> a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Check if all elements satisfy the predicate.
all :: (a -> Bool) -> Vector n a -> Bool

-- | <i>O(n)</i> Check if any element satisfies the predicate.
any :: (a -> Bool) -> Vector n a -> Bool

-- | <i>O(n)</i> Check if all elements are <a>True</a>.
and :: Vector n Bool -> Bool

-- | <i>O(n)</i> Check if any element is <a>True</a>.
or :: Vector n Bool -> Bool

-- | <i>O(n)</i> Compute the sum of the elements.
sum :: Num a => Vector n a -> a

-- | <i>O(n)</i> Compute the product of the elements.
product :: Num a => Vector n a -> a

-- | <i>O(n)</i> Yield the maximum element of the non-empty vector.
maximum :: Ord a => Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the maximum element of the non-empty vector
--   according to the given comparison function.
maximumBy :: (a -> a -> Ordering) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the minimum element of the non-empty vector.
minimum :: Ord a => Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the minimum element of the non-empty vector
--   according to the given comparison function.
minimumBy :: (a -> a -> Ordering) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the index of the maximum element of the non-empty
--   vector.
maxIndex :: Ord a => Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the maximum element of the non-empty
--   vector according to the given comparison function.
maxIndexBy :: (a -> a -> Ordering) -> Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the minimum element of the non-empty
--   vector.
minIndex :: Ord a => Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the minimum element of the non-empty
--   vector according to the given comparison function.
minIndexBy :: (a -> a -> Ordering) -> Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Monadic fold.
foldM :: Monad m => (a -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold (action applied to each element and its
--   index).
ifoldM :: Monad m => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold over non-empty vectors.
fold1M :: Monad m => (a -> a -> m a) -> Vector (1 + n) a -> m a

-- | <i>O(n)</i> Monadic fold with strict accumulator.
foldM' :: Monad m => (a -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold with strict accumulator (action applied to
--   each element and its index).
ifoldM' :: Monad m => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold over non-empty vectors with strict
--   accumulator.
fold1M' :: Monad m => (a -> a -> m a) -> Vector (n + 1) a -> m a

-- | <i>O(n)</i> Monadic fold that discards the result.
foldM_ :: Monad m => (a -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold that discards the result (action applied to
--   each element and its index).
ifoldM_ :: Monad m => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold over non-empty vectors that discards the
--   result.
fold1M_ :: Monad m => (a -> a -> m a) -> Vector (n + 1) a -> m ()

-- | <i>O(n)</i> Monadic fold with strict accumulator that discards the
--   result.
foldM'_ :: Monad m => (a -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold with strict accumulator that discards the
--   result (action applied to each element and its index).
ifoldM'_ :: Monad m => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monad fold over non-empty vectors with strict accumulator
--   that discards the result.
fold1M'_ :: Monad m => (a -> a -> m a) -> Vector (n + 1) a -> m ()

-- | Evaluate each action and collect the results.
sequence :: Monad m => Vector n (m a) -> m (Vector n a)

-- | Evaluate each action and discard the results.
sequence_ :: Monad m => Vector n (m a) -> m ()

-- | <i>O(n)</i> Prescan.
--   
--   <pre>
--   prescanl f z = <a>init</a> . <a>scanl</a> f z
--   </pre>
--   
--   Example: <tt>prescanl (+) 0 &lt;1,2,3,4&gt; = &lt;0,1,3,6&gt;</tt>
prescanl :: (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Prescan with strict accumulator.
prescanl' :: (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Scan.
postscanl :: (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Scan with strict accumulator.
postscanl' :: (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Haskell-style scan.
scanl :: (a -> b -> a) -> a -> Vector n b -> Vector (1 + n) a

-- | <i>O(n)</i> Haskell-style scan with strict accumulator.
scanl' :: (a -> b -> a) -> a -> Vector n b -> Vector (1 + n) a

-- | <i>O(n)</i> Scan over a non-empty vector.
scanl1 :: (a -> a -> a) -> Vector (1 + n) a -> Vector (2 + n) a

-- | <i>O(n)</i> Scan over a non-empty vector with a strict accumulator.
scanl1' :: (a -> a -> a) -> Vector (1 + n) a -> Vector (2 + n) a

-- | <i>O(n)</i> Right-to-left prescan.
prescanr :: (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left prescan with strict accumulator.
prescanr' :: (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left scan.
postscanr :: (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left scan with strict accumulator.
postscanr' :: (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left Haskell-style scan.
scanr :: (a -> b -> b) -> b -> Vector n a -> Vector (n + 1) b

-- | <i>O(n)</i> Right-to-left Haskell-style scan with strict accumulator.
scanr' :: (a -> b -> b) -> b -> Vector n a -> Vector (n + 1) b

-- | <i>O(n)</i> Right-to-left scan over a non-empty vector.
scanr1 :: (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 2) a

-- | <i>O(n)</i> Right-to-left scan over a non-empty vector with a strict
--   accumulator.
scanr1' :: (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 2) a

-- | <i>O(n)</i> Convert a vector to a list.
toList :: Vector n a -> [a]

-- | <i>O(n)</i> Convert a list to a vector.
fromList :: KnownNat n => [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Convert the first <tt>n</tt> elements of a list to a
--   vector. The length of the resulting vector is inferred from the type.
fromListN :: forall n a. KnownNat n => [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Convert the first <tt>n</tt> elements of a list to a
--   vector. The length of the resulting vector is given explicitly as a
--   <a>Proxy</a> argument.
fromListN' :: forall n a p. KnownNat n => p n -> [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Takes a list and returns a continuation providing a vector
--   with a size parameter corresponding to the length of the list.
--   
--   Essentially converts a list into a vector with the proper size
--   parameter, determined at runtime.
--   
--   See <a>withSized</a>
withSizedList :: forall a r. [a] -> (forall n. KnownNat n => Vector n a -> r) -> r

-- | <i>O(n)</i> Yield an immutable copy of the mutable vector.
freeze :: PrimMonad m => MVector n (PrimState m) a -> m (Vector n a)

-- | <i>O(n)</i> Yield a mutable copy of the immutable vector.
thaw :: PrimMonad m => Vector n a -> m (MVector n (PrimState m) a)

-- | <i>O(n)</i> Copy an immutable vector into a mutable one.
copy :: PrimMonad m => MVector n (PrimState m) a -> Vector n a -> m ()

-- | <i>O(1)</i> Unsafely convert a mutable vector to an immutable one
--   without copying. The mutable vector may not be used after this
--   operation.
unsafeFreeze :: PrimMonad m => MVector n (PrimState m) a -> m (Vector n a)

-- | <i>O(n)</i> Unsafely convert an immutable vector to a mutable one
--   without copying. The immutable vector may not be used after this
--   operation.
unsafeThaw :: PrimMonad m => Vector n a -> m (MVector n (PrimState m) a)

-- | Convert a <a>Vector</a> into a <a>Vector</a> if it has the correct
--   size, otherwise return <a>Nothing</a>.
toSized :: forall n a. KnownNat n => Vector a -> Maybe (Vector n a)

-- | Takes a <a>Vector</a> and returns a continuation providing a
--   <a>Vector</a> with a size parameter <tt>n</tt> that is determined at
--   runtime based on the length of the input vector.
--   
--   Essentially converts a <a>Vector</a> into a <a>Vector</a> with the
--   correct size parameter <tt>n</tt>.
withSized :: forall a r. Vector a -> (forall n. KnownNat n => Vector n a -> r) -> r
fromSized :: Vector n a -> Vector a

-- | Apply a function on unsized vectors to a sized vector. The function
--   must preserve the size of the vector, this is not checked.
withVectorUnsafe :: (Vector a -> Vector b) -> Vector n a -> Vector n b

-- | Apply a function on two unsized vectors to sized vectors. The function
--   must preserve the size of the vectors, this is not checked.
zipVectorsUnsafe :: (Vector a -> Vector b -> Vector c) -> Vector n a -> Vector n b -> Vector n c


-- | This module re-exports the functionality in <a>Sized</a> specialized
--   to <a>Mutable</a>.
--   
--   Functions returning a vector determine the size from the type context
--   unless they have a <tt>'</tt> suffix in which case they take an
--   explicit <a>Proxy</a> argument.
--   
--   Functions where the resulting vector size is not known until runtime
--   are not exported.
module Data.Vector.Storable.Mutable.Sized

-- | <a>Vector</a> specialized to use <a>Mutable</a>.
type MVector = MVector MVector

-- | <i>O(1)</i> Yield the length of the mutable vector as an <a>Int</a>.
length :: forall n s a. KnownNat n => MVector n s a -> Int

-- | <i>O(1)</i> Yield the length of the mutable vector as a <a>Proxy</a>.
length' :: forall n s a. () => MVector n s a -> Proxy n

-- | <i>O(1)</i> Check whether the mutable vector is empty.
null :: forall n s a. KnownNat n => MVector n s a -> Bool

-- | <i>O(1)</i> Yield a slice of the mutable vector without copying it
--   with an inferred length argument.
slice :: forall i n k s a p. (KnownNat i, KnownNat n, Storable a) => p i -> MVector ((i + n) + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield a slice of the mutable vector without copying it
--   with an explicit length argument.
slice' :: forall i n k s a p. (KnownNat i, KnownNat n, Storable a) => p i -> p n -> MVector ((i + n) + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the last element of a non-empty mutable
--   vector without copying.
init :: forall n s a. Storable a => MVector (n + 1) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the first element of a non-empty mutable
--   vector without copying.
tail :: forall n s a. Storable a => MVector (1 + n) s a -> MVector n s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is inferred from the type.
take :: forall n k s a. (KnownNat n, Storable a) => MVector (n + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is given explicitly as a <a>Proxy</a> argument.
take' :: forall n k s a p. (KnownNat n, Storable a) => p n -> MVector (n + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is inferred from the type.
drop :: forall n k s a. (KnownNat n, Storable a) => MVector (n + k) s a -> MVector k s a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is givel explicitly as a <a>Proxy</a> argument.
drop' :: forall n k s a p. (KnownNat n, Storable a) => p n -> MVector (n + k) s a -> MVector k s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The lengths of the resulting vectors are inferred
--   from the type.
splitAt :: forall n m s a. (KnownNat n, Storable a) => MVector (n + m) s a -> (MVector n s a, MVector m s a)

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The length of the first resulting vector is passed
--   explicitly as a <a>Proxy</a> argument.
splitAt' :: forall n m s a p. (KnownNat n, Storable a) => p n -> MVector (n + m) s a -> (MVector n s a, MVector m s a)

-- | <i>O(1)</i> Check if two vectors overlap.
overlaps :: forall n k s a. Storable a => MVector n s a -> MVector k s a -> Bool

-- | Create a mutable vector where the length is inferred from the type.
new :: forall n m a. (KnownNat n, PrimMonad m, Storable a) => m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type.
--   The memory is not initialized.
unsafeNew :: forall n m a. (KnownNat n, PrimMonad m, Storable a) => m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type and
--   fill it with an initial value.
replicate :: forall n m a. (KnownNat n, PrimMonad m, Storable a) => a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is given explicitly as a
--   <a>Proxy</a> argument and fill it with an initial value.
replicate' :: forall n m a p. (KnownNat n, PrimMonad m, Storable a) => p n -> a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type and
--   fill it with values produced by repeatedly executing the monadic
--   action.
replicateM :: forall n m a. (KnownNat n, PrimMonad m, Storable a) => m a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is given explicitly as a
--   <a>Proxy</a> argument and fill it with values produced by repeatedly
--   executing the monadic action.
replicateM' :: forall n m a p. (KnownNat n, PrimMonad m, Storable a) => p n -> m a -> m (MVector n (PrimState m) a)

-- | Create a copy of a mutable vector.
clone :: forall n m a. (PrimMonad m, Storable a) => MVector n (PrimState m) a -> m (MVector n (PrimState m) a)

-- | Grow a mutable vector by an amount given explicitly as a <a>Proxy</a>
--   argument.
grow :: forall n k m a p. (KnownNat k, PrimMonad m, Storable a) => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)

-- | Grow a mutable vector (from the front) by an amount given explicitly
--   as a <a>Proxy</a> argument.
growFront :: forall n k m a p. (KnownNat k, PrimMonad m, Storable a) => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)

-- | Reset all elements of the vector to some undefined value, clearing all
--   references to external objects.
clear :: (PrimMonad m, Storable a) => MVector n (PrimState m) a -> m ()

-- | <i>O(1)</i> Yield the element at a given type-safe position using
--   <a>Finite</a>.
read :: forall n m a. (PrimMonad m, Storable a) => MVector n (PrimState m) a -> Finite n -> m a

-- | <i>O(1)</i> Yield the element at a given type-safe position using
--   <a>Proxy</a>.
read' :: forall n k a m p. (KnownNat k, PrimMonad m, Storable a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> m a

-- | <i>O(1)</i> Replace the element at a given type-safe position using
--   <a>Finite</a>.
write :: forall n m a. (PrimMonad m, Storable a) => MVector n (PrimState m) a -> Finite n -> a -> m ()

-- | <i>O(1)</i> Replace the element at a given type-safe position using
--   <a>Proxy</a>.
write' :: forall n k a m p. (KnownNat k, PrimMonad m, Storable a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m ()

-- | <i>O(1)</i> Modify the element at a given type-safe position using
--   <a>Finite</a>.
modify :: forall n m a. (PrimMonad m, Storable a) => MVector n (PrimState m) a -> (a -> a) -> Finite n -> m ()

-- | <i>O(1)</i> Modify the element at a given type-safe position using
--   <a>Proxy</a>.
modify' :: forall n k a m p. (KnownNat k, PrimMonad m, Storable a) => MVector ((n + k) + 1) (PrimState m) a -> (a -> a) -> p k -> m ()

-- | <i>O(1)</i> Swap the elements at the given type-safe positions using
--   <a>Finite</a>s.
swap :: forall n m a. (PrimMonad m, Storable a) => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()

-- | <i>O(1)</i> Replace the element at a given type-safe position and
--   return the old element, using <a>Finite</a>.
exchange :: forall n m a. (PrimMonad m, Storable a) => MVector n (PrimState m) a -> Finite n -> a -> m a

-- | <i>O(1)</i> Replace the element at a given type-safe position and
--   return the old element, using <a>Finite</a>.
exchange' :: forall n k a m p. (KnownNat k, PrimMonad m, Storable a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m a

-- | <i>O(1)</i> Yield the element at a given <a>Int</a> position without
--   bounds checking.
unsafeRead :: forall n a m. (PrimMonad m, Storable a) => MVector n (PrimState m) a -> Int -> m a

-- | <i>O(1)</i> Replace the element at a given <a>Int</a> position without
--   bounds checking.
unsafeWrite :: forall n m a. (PrimMonad m, Storable a) => MVector n (PrimState m) a -> Int -> a -> m ()

-- | <i>O(1)</i> Modify the element at a given <a>Int</a> position without
--   bounds checking.
unsafeModify :: forall n m a. (PrimMonad m, Storable a) => MVector n (PrimState m) a -> (a -> a) -> Int -> m ()

-- | <i>O(1)</i> Swap the elements at the given <a>Int</a> positions
--   without bounds checking.
unsafeSwap :: forall n m a. (PrimMonad m, Storable a) => MVector n (PrimState m) a -> Int -> Int -> m ()

-- | <i>O(1)</i> Replace the element at a given <a>Int</a> position and
--   return the old element. No bounds checks are performed.
unsafeExchange :: forall n m a. (PrimMonad m, Storable a) => MVector n (PrimState m) a -> Int -> a -> m a

-- | Compute the next permutation (lexicographically) of a given vector
--   in-place. Returns <a>False</a> when the input is the last permutation.
nextPermutation :: forall n e m. (Ord e, PrimMonad m, Storable e) => MVector n (PrimState m) e -> m Bool

-- | Set all elements of the vector to the given value.
set :: (PrimMonad m, Storable a) => MVector n (PrimState m) a -> a -> m ()

-- | Copy a vector. The two vectors may not overlap.
copy :: (PrimMonad m, Storable a) => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Move the contents of a vector. If the two vectors do not overlap, this
--   is equivalent to <a>copy</a>. Otherwise, the copying is performed as
--   if the source vector were copied to a temporary vector and then the
--   temporary vector was copied to the target vector.
move :: (PrimMonad m, Storable a) => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Copy a vector. The two vectors may not overlap. This is not checked.
unsafeCopy :: (PrimMonad m, Storable a) => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Convert a <a>MVector</a> into a <a>MVector</a> if it has the correct
--   size, otherwise return Nothing.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
toSized :: forall n a s. (KnownNat n, Storable a) => MVector s a -> Maybe (MVector n s a)

-- | Takes a <a>MVector</a> and returns a continuation providing a
--   <a>MVector</a> with a size parameter <tt>n</tt> that is determined at
--   runtime based on the length of the input vector.
--   
--   Essentially converts a <a>MVector</a> into a <a>MVector</a> with the
--   correct size parameter <tt>n</tt>.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
withSized :: forall s a r. Storable a => MVector s a -> (forall n. KnownNat n => MVector n s a -> r) -> r

-- | Convert a <a>MVector</a> into a <a>MVector</a>.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
fromSized :: MVector n s a -> MVector s a


-- | This module re-exports the functionality in <a>Sized</a> specialized
--   to <a>Storable</a>.
--   
--   Functions returning a vector determine the size from the type context
--   unless they have a <tt>'</tt> suffix in which case they take an
--   explicit <a>Proxy</a> argument.
--   
--   Functions where the resulting vector size is not known until runtime
--   are not exported.
module Data.Vector.Storable.Sized

-- | <a>Vector</a> specialized to use <a>Storable</a>.
type Vector = Vector Vector

-- | Pattern synonym that lets you treat an unsized vector as if it
--   "contained" a sized vector. If you pattern match on an unsized vector,
--   its contents will be the <i>sized</i> vector counterpart.
--   
--   <pre>
--   testFunc :: Unsized.Vector Int -&gt; Int
--   testFunc (<a>SomeSized</a> v) =
--       <a>sum</a> (<a>zipWith</a> (+) v (<a>replicate</a> 1))
--           -- ^ here, v is `Sized.Vector n Int`, and we have
--                       `<a>KnownNat</a> n`
--   </pre>
--   
--   The <tt>n</tt> type variable will be properly instantiated to whatever
--   the length of the vector is, and you will also have a
--   <tt><a>KnownNat</a> n</tt> instance available. You can get <tt>n</tt>
--   in scope by turning on ScopedTypeVariables and matching on
--   <tt><a>SomeSized</a> (v :: Sized.Vector n Int)</tt>.
--   
--   Without this, you would otherwise have to use <a>withSized</a> to do
--   the same thing:
--   
--   <pre>
--   testFunc :: Unsized.Vector Int -&gt; Int
--   testFunc u = <a>withSized</a> u $ \v -&gt;
--       <a>sum</a> (<a>zipWith</a> (+) v (<a>replicate</a> 1))
--   </pre>
--   
--   Remember that the type of final result of your function (the
--   <tt>Int</tt>, here) must <i>not</i> depend on <tt>n</tt>. However, the
--   types of the intermediate values are allowed to depend on <tt>n</tt>.
--   
--   This is <i>especially</i> useful in do blocks, where you can pattern
--   match on the unsized results of actions, to use the sized vector in
--   the rest of the do block. You also get a <tt><a>KnownNat</a> n</tt>
--   constraint for the remainder of the do block.
--   
--   <pre>
--   -- If you had:
--   getAVector :: IO (Unsized.Vector Int)
--   
--   main :: IO ()
--   main = do
--       SomeSized v &lt;- getAVector -- v is `Sized.Vector n Int`
--       -- get n in scope
--       SomeSized (v :: Sized.Vector n Int) &lt;- getAVector
--       print v
--   </pre>
--   
--   Remember that the final type of the result of the do block
--   (<tt>()</tt>, here) must not depend on <tt>n</tt>. However, the
--   
--   Also useful in ghci, where you can pattern match to get sized vectors
--   from unsized vectors.
--   
--   <pre>
--   ghci&gt; SomeSized v &lt;- pure (myUnsizedVector :: Unsized.Vector Int)
--                -- ^ v is `Sized.Vector n Int`
--   </pre>
--   
--   This enables interactive exploration with sized vectors in ghci, and
--   is useful for using with other libraries and functions that expect
--   sized vectors in an interactive setting.
--   
--   (Note that as of GHC 8.6, you cannot get the <tt>n</tt> in scope in
--   your ghci session using ScopedTypeVariables, like you can with do
--   blocks)
--   
--   You can also use this as a constructor, to take a sized vector and
--   "hide" the size, to produce an unsized vector:
--   
--   <pre>
--   SomeSized :: Sized.Vector n a -&gt; Unsized.Vector a
--   </pre>
pattern SomeSized :: Storable a => KnownNat n => Vector n a -> Vector a

-- | <a>Vector</a> specialized to use <a>Mutable</a>.
type MVector = MVector MVector

-- | <i>O(1)</i> Yield the length of the vector as an <a>Int</a>. This is
--   more like <a>natVal</a> than <a>length</a>, extracting the value from
--   the <a>KnownNat</a> instance and not looking at the vector itself.
length :: forall n a. KnownNat n => Vector n a -> Int

-- | <i>O(1)</i> Yield the length of the vector as a <a>Proxy</a>. This
--   function doesn't <i>do</i> anything; it merely allows the size
--   parameter of the vector to be passed around as a <a>Proxy</a>.
length' :: forall n a. Vector n a -> Proxy n

-- | <i>O(1)</i> Reveal a <a>KnownNat</a> instance for a vector's length,
--   determined at runtime.
knownLength :: forall n a r. Storable a => Vector n a -> (KnownNat n => r) -> r

-- | <i>O(1)</i> Reveal a <a>KnownNat</a> instance and <a>Proxy</a> for a
--   vector's length, determined at runtime.
knownLength' :: forall n a r. Storable a => Vector n a -> (KnownNat n => Proxy n -> r) -> r

-- | <i>O(1)</i> Safe indexing using a <a>Finite</a>.
index :: forall n a. Storable a => Vector n a -> Finite n -> a

-- | <i>O(1)</i> Safe indexing using a <a>Proxy</a>.
index' :: forall n m a p. (KnownNat n, Storable a) => Vector ((n + m) + 1) a -> p n -> a

-- | <i>O(1)</i> Indexing using an <a>Int</a> without bounds checking.
unsafeIndex :: forall n a. Storable a => Vector n a -> Int -> a

-- | <i>O(1)</i> Yield the first element of a non-empty vector.
head :: forall n a. Storable a => Vector (1 + n) a -> a

-- | <i>O(1)</i> Yield the last element of a non-empty vector.
last :: forall n a. Storable a => Vector (n + 1) a -> a

-- | <i>O(1)</i> Safe indexing in a monad. See the documentation for
--   <a>indexM</a> for an explanation of why this is useful.
indexM :: forall n a m. (Storable a, Monad m) => Vector n a -> Finite n -> m a

-- | <i>O(1)</i> Safe indexing in a monad using a <a>Proxy</a>. See the
--   documentation for <a>indexM</a> for an explanation of why this is
--   useful.
indexM' :: forall n k a m p. (KnownNat n, Storable a, Monad m) => Vector (n + k) a -> p n -> m a

-- | <i>O(1)</i> Indexing using an <a>Int</a> without bounds checking. See
--   the documentation for <a>indexM</a> for an explanation of why this is
--   useful.
unsafeIndexM :: forall n a m. (Storable a, Monad m) => Vector n a -> Int -> m a

-- | <i>O(1)</i> Yield the first element of a non-empty vector in a monad.
--   See the documentation for <a>indexM</a> for an explanation of why this
--   is useful.
headM :: forall n a m. (Storable a, Monad m) => Vector (1 + n) a -> m a

-- | <i>O(1)</i> Yield the last element of a non-empty vector in a monad.
--   See the documentation for <a>indexM</a> for an explanation of why this
--   is useful.
lastM :: forall n a m. (Storable a, Monad m) => Vector (n + 1) a -> m a

-- | <i>O(1)</i> Yield a slice of the vector without copying it with an
--   inferred length argument.
slice :: forall i n m a p. (KnownNat i, KnownNat n, Storable a) => p i -> Vector ((i + n) + m) a -> Vector n a

-- | <i>O(1)</i> Yield a slice of the vector without copying it with an
--   explicit length argument.
slice' :: forall i n m a p. (KnownNat i, KnownNat n, Storable a) => p i -> p n -> Vector ((i + n) + m) a -> Vector n a

-- | <i>O(1)</i> Yield all but the last element of a non-empty vector
--   without copying.
init :: forall n a. Storable a => Vector (n + 1) a -> Vector n a

-- | <i>O(1)</i> Yield all but the first element of a non-empty vector
--   without copying.
tail :: forall n a. Storable a => Vector (1 + n) a -> Vector n a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is inferred from the type.
take :: forall n m a. (KnownNat n, Storable a) => Vector (n + m) a -> Vector n a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is given explicitly as a <a>Proxy</a> argument.
take' :: forall n m a p. (KnownNat n, Storable a) => p n -> Vector (n + m) a -> Vector n a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is inferred from the type.
drop :: forall n m a. (KnownNat n, Storable a) => Vector (n + m) a -> Vector m a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is givel explicitly as a <a>Proxy</a> argument.
drop' :: forall n m a p. (KnownNat n, Storable a) => p n -> Vector (n + m) a -> Vector m a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The lengths of the resulting vectors are inferred
--   from the type.
splitAt :: forall n m a. (KnownNat n, Storable a) => Vector (n + m) a -> (Vector n a, Vector m a)

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements paired with the
--   remainder without copying. The length of the first resulting vector is
--   passed explicitly as a <a>Proxy</a> argument.
splitAt' :: forall n m a p. (KnownNat n, Storable a) => p n -> Vector (n + m) a -> (Vector n a, Vector m a)

-- | <i>O(1)</i> Empty vector.
empty :: forall a. Storable a => Vector 0 a

-- | <i>O(1)</i> Vector with exactly one element.
singleton :: forall a. Storable a => a -> Vector 1 a

-- | <i>O(n)</i> Construct a vector in a type safe manner <tt> fromTuple
--   (1,2) :: Vector 2 Int fromTuple ("hey", "what's", "going", "on") ::
--   Vector 4 String </tt>
fromTuple :: forall a input length. (Storable a, IndexedListLiterals input length a, KnownNat length) => input -> Vector length a

-- | <i>O(n)</i> Construct a vector with the same element in each position
--   where the length is inferred from the type.
replicate :: forall n a. (KnownNat n, Storable a) => a -> Vector n a

-- | <i>O(n)</i> Construct a vector with the same element in each position
--   where the length is given explicitly as a <a>Proxy</a> argument.
replicate' :: forall n a p. (KnownNat n, Storable a) => p n -> a -> Vector n a

-- | <i>O(n)</i> construct a vector of the given length by applying the
--   function to each index where the length is inferred from the type.
generate :: forall n a. (KnownNat n, Storable a) => (Finite n -> a) -> Vector n a

-- | <i>O(n)</i> construct a vector of the given length by applying the
--   function to each index where the length is given explicitly as a
--   <a>Proxy</a> argument.
generate' :: forall n a p. (KnownNat n, Storable a) => p n -> (Finite n -> a) -> Vector n a

-- | <i>O(n)</i> Apply function <tt>n</tt> times to value. Zeroth element
--   is original value. The length is inferred from the type.
iterateN :: forall n a. (KnownNat n, Storable a) => (a -> a) -> a -> Vector n a

-- | <i>O(n)</i> Apply function <tt>n</tt> times to value. Zeroth element
--   is original value. The length is given explicitly as a <a>Proxy</a>
--   argument.
iterateN' :: forall n a p. (KnownNat n, Storable a) => p n -> (a -> a) -> a -> Vector n a

-- | <i>O(n)</i> Execute the monadic action <tt>n</tt> times and store the
--   results in a vector where <tt>n</tt> is inferred from the type.
replicateM :: forall n m a. (KnownNat n, Storable a, Monad m) => m a -> m (Vector n a)

-- | <i>O(n)</i> Execute the monadic action <tt>n</tt> times and store the
--   results in a vector where <tt>n</tt> is given explicitly as a
--   <a>Proxy</a> argument.
replicateM' :: forall n m a p. (KnownNat n, Storable a, Monad m) => p n -> m a -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector of length <tt>n</tt> by applying the
--   monadic action to each index where <tt>n</tt> is inferred from the
--   type.
generateM :: forall n m a. (KnownNat n, Storable a, Monad m) => (Finite n -> m a) -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector of length <tt>n</tt> by applying the
--   monadic action to each index where <tt>n</tt> is given explicitly as a
--   <a>Proxy</a> argument.
generateM' :: forall n m a p. (KnownNat n, Storable a, Monad m) => p n -> (Finite n -> m a) -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector with exactly <tt>n</tt> elements by
--   repeatedly applying the generator function to the a seed. The length
--   is inferred from the type.
unfoldrN :: forall n a b. (KnownNat n, Storable a) => (b -> (a, b)) -> b -> Vector n a

-- | <i>O(n)</i> Construct a vector with exactly <tt>n</tt> elements by
--   repeatedly applying the generator function to the a seed. The length
--   is given explicitly as a <a>Proxy</a> argument.
unfoldrN' :: forall n a b p. (KnownNat n, Storable a) => p n -> (b -> (a, b)) -> b -> Vector n a

-- | <i>O(n)</i> Yield a vector of length <tt>n</tt> containing the values
--   <tt>x</tt>, <tt>x+1</tt>, ..., <tt>x + (n - 1)</tt>. The length is
--   inferred from the type.
enumFromN :: forall n a. (KnownNat n, Storable a, Num a) => a -> Vector n a

-- | <i>O(n)</i> Yield a vector of length <tt>n</tt> containing the values
--   <tt>x</tt>, <tt>x+1</tt>, ..., <tt>x + (n - 1)</tt>. The length is
--   given explicitly as a <a>Proxy</a> argument.
enumFromN' :: forall n a p. (KnownNat n, Storable a, Num a) => a -> p n -> Vector n a

-- | <i>O(n)</i> Yield a vector of the given length containing the values
--   <tt>x</tt>, <tt>x+y</tt>, <tt>x+2y</tt>, ..., <tt>x + (n - 1)y</tt>.
--   The length is inferred from the type.
enumFromStepN :: forall n a. (KnownNat n, Storable a, Num a) => a -> a -> Vector n a

-- | <i>O(n)</i> Yield a vector of the given length containing the values
--   <tt>x</tt>, <tt>x+y</tt>, <tt>x+2y</tt>, ..., <tt>x + (n - 1)y</tt>.
--   The length is given explicitly as a <a>Proxy</a> argument.
enumFromStepN' :: forall n a p. (KnownNat n, Storable a, Num a) => a -> a -> p n -> Vector n a

-- | <i>O(n)</i> Prepend an element.
cons :: forall n a. Storable a => a -> Vector n a -> Vector (1 + n) a

-- | <i>O(n)</i> Append an element.
snoc :: forall n a. Storable a => Vector n a -> a -> Vector (n + 1) a

-- | <i>O(m+n)</i> Concatenate two vectors.
(++) :: forall n m a. Storable a => Vector n a -> Vector m a -> Vector (n + m) a

-- | <i>O(n)</i> Yield the argument but force it not to retain any extra
--   memory, possibly by copying it.
--   
--   This is especially useful when dealing with slices. For example:
--   
--   <pre>
--   force (slice 0 2 &lt;huge vector&gt;)
--   </pre>
--   
--   Here, the slice retains a reference to the huge vector. Forcing it
--   creates a copy of just the elements that belong to the slice and
--   allows the huge vector to be garbage collected.
force :: Storable a => Vector n a -> Vector n a

-- | <i>O(m+n)</i> For each pair <tt>(i,a)</tt> from the list, replace the
--   vector element at position <tt>i</tt> by <tt>a</tt>.
--   
--   <pre>
--   &lt;5,9,2,7&gt; // [(2,1),(0,3),(2,8)] = &lt;3,9,8,7&gt;
--   </pre>
(//) :: Storable a => Vector m a -> [(Finite m, a)] -> Vector m a

-- | <i>O(m+n)</i> For each pair <tt>(i,a)</tt> from the vector of
--   index/value pairs, replace the vector element at position <tt>i</tt>
--   by <tt>a</tt>.
--   
--   <pre>
--   update &lt;5,9,2,7&gt; &lt;(2,1),(0,3),(2,8)&gt; = &lt;3,9,8,7&gt;
--   </pre>
update :: (Storable a, Storable (Int, a)) => Vector m a -> Vector n (Int, a) -> Vector m a

-- | <i>O(m+n)</i> For each index <tt>i</tt> from the index vector and the
--   corresponding value <tt>a</tt> from the value vector, replace the
--   element of the initial vector at position <tt>i</tt> by <tt>a</tt>.
--   
--   <pre>
--   update_ &lt;5,9,2,7&gt;  &lt;2,0,2&gt; &lt;1,3,8&gt; = &lt;3,9,8,7&gt;
--   </pre>
--   
--   This function is useful for instances of <a>Vector</a> that cannot
--   store pairs. Otherwise, <a>update</a> is probably more convenient.
--   
--   <pre>
--   update_ xs is ys = <a>update</a> xs (<a>zip</a> is ys)
--   </pre>
update_ :: Storable a => Vector m a -> Vector n Int -> Vector n a -> Vector m a

-- | Same as (<a>//</a>) but without bounds checking.
unsafeUpd :: Storable a => Vector m a -> [(Int, a)] -> Vector m a

-- | Same as <a>update</a> but without bounds checking.
unsafeUpdate :: (Storable a, Storable (Int, a)) => Vector m a -> Vector n (Int, a) -> Vector m a

-- | Same as <a>update_</a> but without bounds checking.
unsafeUpdate_ :: Storable a => Vector m a -> Vector n Int -> Vector n a -> Vector m a

-- | <i>O(m+n)</i> For each pair <tt>(i,b)</tt> from the list, replace the
--   vector element <tt>a</tt> at position <tt>i</tt> by <tt>f a b</tt>.
--   
--   <pre>
--   accum (+) &lt;5,9,2&gt; [(2,4),(1,6),(0,3),(1,7)] = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
accum :: Storable a => (a -> b -> a) -> Vector m a -> [(Finite m, b)] -> Vector m a

-- | <i>O(m+n)</i> For each pair <tt>(i,b)</tt> from the vector of pairs,
--   replace the vector element <tt>a</tt> at position <tt>i</tt> by <tt>f
--   a b</tt>.
--   
--   <pre>
--   accumulate (+) &lt;5,9,2&gt; &lt;(2,4),(1,6),(0,3),(1,7)&gt; = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
accumulate :: (Storable a, Storable (Int, b)) => (a -> b -> a) -> Vector m a -> Vector n (Int, b) -> Vector m a

-- | <i>O(m+n)</i> For each index <tt>i</tt> from the index vector and the
--   corresponding value <tt>b</tt> from the the value vector, replace the
--   element of the initial vector at position <tt>i</tt> by <tt>f a
--   b</tt>.
--   
--   <pre>
--   accumulate_ (+) &lt;5,9,2&gt; &lt;2,1,0,1&gt; &lt;4,6,3,7&gt; = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
--   
--   This function is useful for instances of <a>Vector</a> that cannot
--   store pairs. Otherwise, <a>accumulate</a> is probably more convenient:
--   
--   <pre>
--   accumulate_ f as is bs = <a>accumulate</a> f as (<a>zip</a> is bs)
--   </pre>
accumulate_ :: (Storable a, Storable b) => (a -> b -> a) -> Vector m a -> Vector n Int -> Vector n b -> Vector m a

-- | Same as <a>accum</a> but without bounds checking.
unsafeAccum :: Storable a => (a -> b -> a) -> Vector m a -> [(Int, b)] -> Vector m a

-- | Same as <a>accumulate</a> but without bounds checking.
unsafeAccumulate :: (Storable a, Storable (Int, b)) => (a -> b -> a) -> Vector m a -> Vector n (Int, b) -> Vector m a

-- | Same as <a>accumulate_</a> but without bounds checking.
unsafeAccumulate_ :: (Storable a, Storable b) => (a -> b -> a) -> Vector m a -> Vector n Int -> Vector n b -> Vector m a

-- | <i>O(n)</i> Reverse a vector.
reverse :: Storable a => Vector n a -> Vector n a

-- | <i>O(n)</i> Yield the vector obtained by replacing each element
--   <tt>i</tt> of the index vector by <tt>xs<tt>!</tt>i</tt>. This is
--   equivalent to <tt><a>map</a> (xs<tt>!</tt>) is</tt> but is often much
--   more efficient.
--   
--   <pre>
--   backpermute &lt;a,b,c,d&gt; &lt;0,3,2,3,1,0&gt; = &lt;a,d,c,d,b,a&gt;
--   </pre>
backpermute :: Storable a => Vector m a -> Vector n Int -> Vector n a

-- | Same as <a>backpermute</a> but without bounds checking.
unsafeBackpermute :: Storable a => Vector m a -> Vector n Int -> Vector n a

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) an arbitrary
--   element by its index.
ix :: forall n a f. (Storable a, Functor f) => Finite n -> (a -> f a) -> Vector n a -> f (Vector n a)

-- | Type-safe lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) an
--   arbitrary element by its index which should be supplied via
--   TypeApplications.
ix' :: forall i n a f. (Storable a, Functor f, KnownNat i, KnownNat n, (i + 1) <= n) => (a -> f a) -> Vector n a -> f (Vector n a)

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) the first
--   element of a non-empty vector.
_head :: forall n a f. (Storable a, Functor f) => (a -> f a) -> Vector (1 + n) a -> f (Vector (1 + n) a)

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) the last element
--   of a non-empty vector.
_last :: forall n a f. (Storable a, Functor f) => (a -> f a) -> Vector (n + 1) a -> f (Vector (n + 1) a)

-- | <i>O(n)</i> Pair each element in a vector with its index.
indexed :: (Storable a, Storable (Int, a), Storable (Finite n, a)) => Vector n a -> Vector n (Finite n, a)

-- | <i>O(n)</i> Map a function over a vector.
map :: (Storable a, Storable b) => (a -> b) -> Vector n a -> Vector n b

-- | <i>O(n)</i> Apply a function to every element of a vector and its
--   index.
imap :: (Storable a, Storable b) => (Finite n -> a -> b) -> Vector n a -> Vector n b

-- | <i>O(n*m)</i> Map a function over a vector and concatenate the
--   results. The function is required to always return the same length
--   vector.
concatMap :: (Storable a, Storable b) => (a -> Vector m b) -> Vector n a -> Vector (n * m) b

-- | <i>O(n)</i> Apply the monadic action to all elements of the vector,
--   yielding a vector of results.
mapM :: (Monad m, Storable a, Storable b) => (a -> m b) -> Vector n a -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to every element of a vector and
--   its index, yielding a vector of results.
imapM :: (Monad m, Storable a, Storable b) => (Finite n -> a -> m b) -> Vector n a -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to all elements of a vector and
--   ignore the results.
mapM_ :: (Monad m, Storable a) => (a -> m b) -> Vector n a -> m ()

-- | <i>O(n)</i> Apply the monadic action to every element of a vector and
--   its index, ignoring the results.
imapM_ :: (Monad m, Storable a) => (Finite n -> a -> m b) -> Vector n a -> m ()

-- | <i>O(n)</i> Apply the monadic action to all elements of the vector,
--   yielding a vector of results. Equvalent to <tt>flip <a>mapM</a></tt>.
forM :: (Monad m, Storable a, Storable b) => Vector n a -> (a -> m b) -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to all elements of a vector and
--   ignore the results. Equivalent to <tt>flip <a>mapM_</a></tt>.
forM_ :: (Monad m, Storable a) => Vector n a -> (a -> m b) -> m ()

-- | <i>O(n)</i> Zip two vectors of the same length with the given
--   function.
zipWith :: (Storable a, Storable b, Storable c) => (a -> b -> c) -> Vector n a -> Vector n b -> Vector n c

-- | Zip three vectors with the given function.
zipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (a -> b -> c -> d) -> Vector n a -> Vector n b -> Vector n c -> Vector n d
zipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
zipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f) => (a -> b -> c -> d -> e -> f) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f
zipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable g) => (a -> b -> c -> d -> e -> f -> g) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n g

-- | <i>O(n)</i> Zip two vectors of the same length with a function that
--   also takes the elements' indices).
izipWith :: (Storable a, Storable b, Storable c) => (Finite n -> a -> b -> c) -> Vector n a -> Vector n b -> Vector n c
izipWith3 :: (Storable a, Storable b, Storable c, Storable d) => (Finite n -> a -> b -> c -> d) -> Vector n a -> Vector n b -> Vector n c -> Vector n d
izipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (Finite n -> a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
izipWith5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f) => (Finite n -> a -> b -> c -> d -> e -> f) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f
izipWith6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable g) => (Finite n -> a -> b -> c -> d -> e -> f -> g) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n g

-- | <i>O(n)</i> Zip two vectors of the same length.
zip :: (Storable a, Storable b, Storable (a, b)) => Vector n a -> Vector n b -> Vector n (a, b)
zip3 :: (Storable a, Storable b, Storable c, Storable (a, b, c)) => Vector n a -> Vector n b -> Vector n c -> Vector n (a, b, c)
zip4 :: (Storable a, Storable b, Storable c, Storable d, Storable (a, b, c, d)) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n (a, b, c, d)
zip5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable (a, b, c, d, e)) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n (a, b, c, d, e)
zip6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable (a, b, c, d, e, f)) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n (a, b, c, d, e, f)

-- | <i>O(n)</i> Zip the two vectors of the same length with the monadic
--   action and yield a vector of results.
zipWithM :: (Monad m, Storable a, Storable b, Storable c) => (a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)

-- | <i>O(n)</i> Zip the two vectors with a monadic action that also takes
--   the element index and yield a vector of results.
izipWithM :: (Monad m, Storable a, Storable b, Storable c) => (Finite n -> a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)

-- | <i>O(n)</i> Zip the two vectors with the monadic action and ignore the
--   results.
zipWithM_ :: (Monad m, Storable a, Storable b) => (a -> b -> m c) -> Vector n a -> Vector n b -> m ()

-- | <i>O(n)</i> Zip the two vectors with a monadic action that also takes
--   the element index and ignore the results.
izipWithM_ :: (Monad m, Storable a, Storable b) => (Finite n -> a -> b -> m c) -> Vector n a -> Vector n b -> m ()

-- | <i>O(min(m,n))</i> Unzip a vector of pairs.
unzip :: (Storable a, Storable b, Storable (a, b)) => Vector n (a, b) -> (Vector n a, Vector n b)
unzip3 :: (Storable a, Storable b, Storable c, Storable (a, b, c)) => Vector n (a, b, c) -> (Vector n a, Vector n b, Vector n c)
unzip4 :: (Storable a, Storable b, Storable c, Storable d, Storable (a, b, c, d)) => Vector n (a, b, c, d) -> (Vector n a, Vector n b, Vector n c, Vector n d)
unzip5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable (a, b, c, d, e)) => Vector n (a, b, c, d, e) -> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e)
unzip6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable (a, b, c, d, e, f)) => Vector n (a, b, c, d, e, f) -> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e, Vector n f)

-- | <i>O(n)</i> Check if the vector contains an element.
elem :: (Storable a, Eq a) => a -> Vector n a -> Bool
infix 4 `elem`

-- | <i>O(n)</i> Check if the vector does not contain an element (inverse
--   of <a>elem</a>).
notElem :: (Storable a, Eq a) => a -> Vector n a -> Bool
infix 4 `notElem`

-- | <i>O(n)</i> Yield <a>Just</a> the first element matching the predicate
--   or <a>Nothing</a> if no such element exists.
find :: Storable a => (a -> Bool) -> Vector n a -> Maybe a

-- | <i>O(n)</i> Yield <a>Just</a> the index of the first element matching
--   the predicate or <a>Nothing</a> if no such element exists.
findIndex :: Storable a => (a -> Bool) -> Vector n a -> Maybe (Finite n)

-- | <i>O(n)</i> Yield <a>Just</a> the index of the first occurence of the
--   given element or <a>Nothing</a> if the vector does not contain the
--   element. This is a specialised version of <a>findIndex</a>.
elemIndex :: (Storable a, Eq a) => a -> Vector n a -> Maybe (Finite n)

-- | <i>O(n)</i> Left fold.
foldl :: Storable b => (a -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold on non-empty vectors.
foldl1 :: Storable a => (a -> a -> a) -> Vector (1 + n) a -> a

-- | <i>O(n)</i> Left fold with strict accumulator.
foldl' :: Storable b => (a -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold on non-empty vectors with strict accumulator.
foldl1' :: Storable a => (a -> a -> a) -> Vector (1 + n) a -> a

-- | <i>O(n)</i> Right fold.
foldr :: Storable a => (a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold on non-empty vectors.
foldr1 :: Storable a => (a -> a -> a) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Right fold with a strict accumulator.
foldr' :: Storable a => (a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold on non-empty vectors with strict accumulator.
foldr1' :: Storable a => (a -> a -> a) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Left fold (function applied to each element and its
--   index).
ifoldl :: Storable b => (a -> Finite n -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold with strict accumulator (function applied to
--   each element and its index).
ifoldl' :: Storable b => (a -> Finite n -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Right fold (function applied to each element and its
--   index).
ifoldr :: Storable a => (Finite n -> a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold with strict accumulator (function applied to
--   each element and its index).
ifoldr' :: Storable a => (Finite n -> a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Check if all elements satisfy the predicate.
all :: Storable a => (a -> Bool) -> Vector n a -> Bool

-- | <i>O(n)</i> Check if any element satisfies the predicate.
any :: Storable a => (a -> Bool) -> Vector n a -> Bool

-- | <i>O(n)</i> Check if all elements are <a>True</a>
and :: Vector n Bool -> Bool

-- | <i>O(n)</i> Check if any element is <a>True</a>
or :: Vector n Bool -> Bool

-- | <i>O(n)</i> Compute the sum of the elements.
sum :: (Storable a, Num a) => Vector n a -> a

-- | <i>O(n)</i> Compute the product of the elements.
product :: (Storable a, Num a) => Vector n a -> a

-- | <i>O(n)</i> Yield the maximum element of the non-empty vector.
maximum :: (Storable a, Ord a) => Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the maximum element of the non-empty vector
--   according to the given comparison function.
maximumBy :: Storable a => (a -> a -> Ordering) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the minimum element of the non-empty vector.
minimum :: (Storable a, Ord a) => Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the minimum element of the non-empty vector
--   according to the given comparison function.
minimumBy :: Storable a => (a -> a -> Ordering) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the index of the maximum element of the non-empty
--   vector.
maxIndex :: (Storable a, Ord a) => Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the maximum element of the non-empty
--   vector according to the given comparison function.
maxIndexBy :: Storable a => (a -> a -> Ordering) -> Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the minimum element of the non-empty
--   vector.
minIndex :: (Storable a, Ord a) => Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the minimum element of the non-empty
--   vector according to the given comparison function.
minIndexBy :: Storable a => (a -> a -> Ordering) -> Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Monadic fold.
foldM :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold (action applied to each element and its
--   index).
ifoldM :: (Monad m, Storable b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold over non-empty vectors.
fold1M :: (Monad m, Storable a) => (a -> a -> m a) -> Vector (1 + n) a -> m a

-- | <i>O(n)</i> Monadic fold with strict accumulator.
foldM' :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold with strict accumulator (action applied to
--   each element and its index).
ifoldM' :: (Monad m, Storable b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold over non-empty vectors with strict
--   accumulator.
fold1M' :: (Monad m, Storable a) => (a -> a -> m a) -> Vector (n + 1) a -> m a

-- | <i>O(n)</i> Monadic fold that discards the result.
foldM_ :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold that discards the result (action applied to
--   each element and its index).
ifoldM_ :: (Monad m, Storable b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold over non-empty vectors that discards the
--   result.
fold1M_ :: (Monad m, Storable a) => (a -> a -> m a) -> Vector (n + 1) a -> m ()

-- | <i>O(n)</i> Monadic fold with strict accumulator that discards the
--   result.
foldM'_ :: (Monad m, Storable b) => (a -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold with strict accumulator that discards the
--   result (action applied to each element and its index).
ifoldM'_ :: (Monad m, Storable b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monad fold over non-empty vectors with strict accumulator
--   that discards the result.
fold1M'_ :: (Monad m, Storable a) => (a -> a -> m a) -> Vector (n + 1) a -> m ()

-- | Evaluate each action and collect the results.
sequence :: (Monad m, Storable a, Storable (m a)) => Vector n (m a) -> m (Vector n a)

-- | Evaluate each action and discard the results.
sequence_ :: (Monad m, Storable (m a)) => Vector n (m a) -> m ()

-- | <i>O(n)</i> Prescan.
--   
--   <pre>
--   prescanl f z = <a>init</a> . <a>scanl</a> f z
--   </pre>
--   
--   Example: <tt>prescanl (+) 0 &lt;1,2,3,4&gt; = &lt;0,1,3,6&gt;</tt>
prescanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Prescan with strict accumulator.
prescanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Scan.
postscanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Scan with strict accumulator.
postscanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Haskell-style scan.
scanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector (1 + n) a

-- | <i>O(n)</i> Haskell-style scan with strict accumulator.
scanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector (1 + n) a

-- | <i>O(n)</i> Scan over a non-empty vector.
scanl1 :: Storable a => (a -> a -> a) -> Vector (1 + n) a -> Vector (2 + n) a

-- | <i>O(n)</i> Scan over a non-empty vector with a strict accumulator.
scanl1' :: Storable a => (a -> a -> a) -> Vector (1 + n) a -> Vector (2 + n) a

-- | <i>O(n)</i> Right-to-left prescan.
prescanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left prescan with strict accumulator.
prescanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left scan.
postscanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left scan with strict accumulator.
postscanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left Haskell-style scan.
scanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector (n + 1) b

-- | <i>O(n)</i> Right-to-left Haskell-style scan with strict accumulator.
scanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector (n + 1) b

-- | <i>O(n)</i> Right-to-left scan over a non-empty vector.
scanr1 :: Storable a => (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 2) a

-- | <i>O(n)</i> Right-to-left scan over a non-empty vector with a strict
--   accumulator.
scanr1' :: Storable a => (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 2) a

-- | <i>O(n)</i> Convert a vector to a list.
toList :: Storable a => Vector n a -> [a]

-- | <i>O(n)</i> Convert a list to a vector.
fromList :: (Storable a, KnownNat n) => [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Convert the first <tt>n</tt> elements of a list to a
--   vector. The length of the resulting vector is inferred from the type.
fromListN :: forall n a. (Storable a, KnownNat n) => [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Convert the first <tt>n</tt> elements of a list to a
--   vector. The length of the resulting vector is given explicitly as a
--   <a>Proxy</a> argument.
fromListN' :: forall n a p. (Storable a, KnownNat n) => p n -> [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Takes a list and returns a continuation providing a vector
--   with a size parameter corresponding to the length of the list.
--   
--   Essentially converts a list into a vector with the proper size
--   parameter, determined at runtime.
--   
--   See <a>withSized</a>
withSizedList :: forall a r. Storable a => [a] -> (forall n. KnownNat n => Vector n a -> r) -> r

-- | <i>O(n)</i> Yield an immutable copy of the mutable vector.
freeze :: (PrimMonad m, Storable a) => MVector n (PrimState m) a -> m (Vector n a)

-- | <i>O(n)</i> Yield a mutable copy of the immutable vector.
thaw :: (PrimMonad m, Storable a) => Vector n a -> m (MVector n (PrimState m) a)

-- | <i>O(n)</i> Copy an immutable vector into a mutable one.
copy :: (PrimMonad m, Storable a) => MVector n (PrimState m) a -> Vector n a -> m ()

-- | <i>O(1)</i> Unsafely convert a mutable vector to an immutable one
--   withouy copying. The mutable vector may not be used after this
--   operation.
unsafeFreeze :: (PrimMonad m, Storable a) => MVector n (PrimState m) a -> m (Vector n a)

-- | <i>O(n)</i> Unsafely convert an immutable vector to a mutable one
--   without copying. The immutable vector may not be used after this
--   operation.
unsafeThaw :: (PrimMonad m, Storable a) => Vector n a -> m (MVector n (PrimState m) a)

-- | Convert a <a>Vector</a> into a <a>Vector</a> if it has the correct
--   size, otherwise return <a>Nothing</a>.
toSized :: forall n a. (Storable a, KnownNat n) => Vector a -> Maybe (Vector n a)

-- | Takes a <a>Vector</a> and returns a continuation providing a
--   <a>Vector</a> with a size parameter <tt>n</tt> that is determined at
--   runtime based on the length of the input vector.
--   
--   Essentially converts a <a>Vector</a> into a <a>Vector</a> with the
--   correct size parameter <tt>n</tt>.
withSized :: forall a r. Storable a => Vector a -> (forall n. KnownNat n => Vector n a -> r) -> r
fromSized :: Vector n a -> Vector a

-- | Apply a function on unsized vectors to a sized vector. The function
--   must preserve the size of the vector, this is not checked.
withVectorUnsafe :: forall a b (n :: Nat). () => (Vector a -> Vector b) -> Vector n a -> Vector n b

-- | Apply a function on two unsized vectors to sized vectors. The function
--   must preserve the size of the vectors, this is not checked.
zipVectorsUnsafe :: (Vector a -> Vector b -> Vector c) -> Vector n a -> Vector n b -> Vector n c


-- | This module re-exports the functionality in <a>Sized</a> specialized
--   to <a>Mutable</a>.
--   
--   Functions returning a vector determine the size from the type context
--   unless they have a <tt>'</tt> suffix in which case they take an
--   explicit <a>Proxy</a> argument.
--   
--   Functions where the resulting vector size is not known until runtime
--   are not exported.
module Data.Vector.Unboxed.Mutable.Sized

-- | <a>Vector</a> specialized to use <a>Mutable</a>.
type MVector = MVector MVector

-- | <i>O(1)</i> Yield the length of the mutable vector as an <a>Int</a>.
length :: forall n s a. KnownNat n => MVector n s a -> Int

-- | <i>O(1)</i> Yield the length of the mutable vector as a <a>Proxy</a>.
length' :: forall n s a. () => MVector n s a -> Proxy n

-- | <i>O(1)</i> Check whether the mutable vector is empty.
null :: forall n s a. KnownNat n => MVector n s a -> Bool

-- | <i>O(1)</i> Yield a slice of the mutable vector without copying it
--   with an inferred length argument.
slice :: forall i n k s a p. (KnownNat i, KnownNat n, Unbox a) => p i -> MVector ((i + n) + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield a slice of the mutable vector without copying it
--   with an explicit length argument.
slice' :: forall i n k s a p. (KnownNat i, KnownNat n, Unbox a) => p i -> p n -> MVector ((i + n) + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the last element of a non-empty mutable
--   vector without copying.
init :: forall n s a. Unbox a => MVector (n + 1) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the first element of a non-empty mutable
--   vector without copying.
tail :: forall n s a. Unbox a => MVector (1 + n) s a -> MVector n s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is inferred from the type.
take :: forall n k s a. (KnownNat n, Unbox a) => MVector (n + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is given explicitly as a <a>Proxy</a> argument.
take' :: forall n k s a p. (KnownNat n, Unbox a) => p n -> MVector (n + k) s a -> MVector n s a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is inferred from the type.
drop :: forall n k s a. (KnownNat n, Unbox a) => MVector (n + k) s a -> MVector k s a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is givel explicitly as a <a>Proxy</a> argument.
drop' :: forall n k s a p. (KnownNat n, Unbox a) => p n -> MVector (n + k) s a -> MVector k s a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The lengths of the resulting vectors are inferred
--   from the type.
splitAt :: forall n m s a. (KnownNat n, Unbox a) => MVector (n + m) s a -> (MVector n s a, MVector m s a)

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The length of the first resulting vector is passed
--   explicitly as a <a>Proxy</a> argument.
splitAt' :: forall n m s a p. (KnownNat n, Unbox a) => p n -> MVector (n + m) s a -> (MVector n s a, MVector m s a)

-- | <i>O(1)</i> Check if two vectors overlap.
overlaps :: forall n k s a. Unbox a => MVector n s a -> MVector k s a -> Bool

-- | Create a mutable vector where the length is inferred from the type.
new :: forall n m a. (KnownNat n, PrimMonad m, Unbox a) => m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type.
--   The memory is not initialized.
unsafeNew :: forall n m a. (KnownNat n, PrimMonad m, Unbox a) => m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type and
--   fill it with an initial value.
replicate :: forall n m a. (KnownNat n, PrimMonad m, Unbox a) => a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is given explicitly as a
--   <a>Proxy</a> argument and fill it with an initial value.
replicate' :: forall n m a p. (KnownNat n, PrimMonad m, Unbox a) => p n -> a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is inferred from the type and
--   fill it with values produced by repeatedly executing the monadic
--   action.
replicateM :: forall n m a. (KnownNat n, PrimMonad m, Unbox a) => m a -> m (MVector n (PrimState m) a)

-- | Create a mutable vector where the length is given explicitly as a
--   <a>Proxy</a> argument and fill it with values produced by repeatedly
--   executing the monadic action.
replicateM' :: forall n m a p. (KnownNat n, PrimMonad m, Unbox a) => p n -> m a -> m (MVector n (PrimState m) a)

-- | Create a copy of a mutable vector.
clone :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> m (MVector n (PrimState m) a)

-- | Grow a mutable vector by an amount given explicitly as a <a>Proxy</a>
--   argument.
grow :: forall n k m a p. (KnownNat k, PrimMonad m, Unbox a) => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)

-- | Grow a mutable vector (from the front) by an amount given explicitly
--   as a <a>Proxy</a> argument.
growFront :: forall n k m a p. (KnownNat k, PrimMonad m, Unbox a) => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)

-- | Reset all elements of the vector to some undefined value, clearing all
--   references to external objects.
clear :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> m ()

-- | <i>O(1)</i> Yield the element at a given type-safe position using
--   <a>Finite</a>.
read :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Finite n -> m a

-- | <i>O(1)</i> Yield the element at a given type-safe position using
--   <a>Proxy</a>.
read' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> m a

-- | <i>O(1)</i> Replace the element at a given type-safe position using
--   <a>Finite</a>.
write :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Finite n -> a -> m ()

-- | <i>O(1)</i> Replace the element at a given type-safe position using
--   <a>Proxy</a>.
write' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m ()

-- | <i>O(1)</i> Modify the element at a given type-safe position using
--   <a>Finite</a>.
modify :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> (a -> a) -> Finite n -> m ()

-- | <i>O(1)</i> Modify the element at a given type-safe position using
--   <a>Proxy</a>.
modify' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a) => MVector ((n + k) + 1) (PrimState m) a -> (a -> a) -> p k -> m ()

-- | <i>O(1)</i> Swap the elements at the given type-safe positions using
--   <a>Finite</a>s.
swap :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()

-- | <i>O(1)</i> Replace the element at a given type-safe position and
--   return the old element, using <a>Finite</a>.
exchange :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Finite n -> a -> m a

-- | <i>O(1)</i> Replace the element at a given type-safe position and
--   return the old element, using <a>Finite</a>.
exchange' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a) => MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m a

-- | <i>O(1)</i> Yield the element at a given <a>Int</a> position without
--   bounds checking.
unsafeRead :: forall n a m. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Int -> m a

-- | <i>O(1)</i> Replace the element at a given <a>Int</a> position without
--   bounds checking.
unsafeWrite :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Int -> a -> m ()

-- | <i>O(1)</i> Modify the element at a given <a>Int</a> position without
--   bounds checking.
unsafeModify :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> (a -> a) -> Int -> m ()

-- | <i>O(1)</i> Swap the elements at the given <a>Int</a> positions
--   without bounds checking.
unsafeSwap :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Int -> Int -> m ()

-- | <i>O(1)</i> Replace the element at a given <a>Int</a> position and
--   return the old element. No bounds checks are performed.
unsafeExchange :: forall n m a. (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Int -> a -> m a

-- | Compute the next permutation (lexicographically) of a given vector
--   in-place. Returns <a>False</a> when the input is the last permutation.
nextPermutation :: forall n e m. (Ord e, PrimMonad m, Unbox e) => MVector n (PrimState m) e -> m Bool

-- | Set all elements of the vector to the given value.
set :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> a -> m ()

-- | Copy a vector. The two vectors may not overlap.
copy :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Move the contents of a vector. If the two vectors do not overlap, this
--   is equivalent to <a>copy</a>. Otherwise, the copying is performed as
--   if the source vector were copied to a temporary vector and then the
--   temporary vector was copied to the target vector.
move :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Copy a vector. The two vectors may not overlap. This is not checked.
unsafeCopy :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()

-- | Convert a <a>MVector</a> into a <a>MVector</a> if it has the correct
--   size, otherwise return Nothing.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
toSized :: forall n a s. (KnownNat n, Unbox a) => MVector s a -> Maybe (MVector n s a)

-- | Takes a <a>MVector</a> and returns a continuation providing a
--   <a>MVector</a> with a size parameter <tt>n</tt> that is determined at
--   runtime based on the length of the input vector.
--   
--   Essentially converts a <a>MVector</a> into a <a>MVector</a> with the
--   correct size parameter <tt>n</tt>.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
withSized :: forall s a r. Unbox a => MVector s a -> (forall n. KnownNat n => MVector n s a -> r) -> r

-- | Convert a <a>MVector</a> into a <a>MVector</a>.
--   
--   Note that this does no copying; the returned <a>MVector</a> is a
--   reference to the exact same vector in memory as the given one, and any
--   modifications to it are also reflected in the given <a>MVector</a>.
fromSized :: MVector n s a -> MVector s a
class (Vector Vector a, MVector MVector a) => Unbox a
instance (Data.Vector.Unboxed.Base.Unbox a, GHC.TypeNats.KnownNat n) => Data.Vector.Unboxed.Base.Unbox (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Unboxed.Base.Vector n a)
instance (Data.Vector.Unboxed.Base.Unbox a, GHC.TypeNats.KnownNat n) => Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Unboxed.Base.Vector n a)
instance (Data.Vector.Unboxed.Base.Unbox a, GHC.TypeNats.KnownNat n) => Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Data.Vector.Generic.Sized.Internal.Vector Data.Vector.Unboxed.Base.Vector n a)


-- | This module re-exports the functionality in <a>Sized</a> specialized
--   to <a>Unboxed</a>.
--   
--   Functions returning a vector determine the size from the type context
--   unless they have a <tt>'</tt> suffix in which case they take an
--   explicit <a>Proxy</a> argument.
--   
--   Functions where the resulting vector size is not known until runtime
--   are not exported.
module Data.Vector.Unboxed.Sized

-- | <a>Vector</a> specialized to use <a>Unboxed</a>.
type Vector = Vector Vector

-- | Pattern synonym that lets you treat an unsized vector as if it
--   "contained" a sized vector. If you pattern match on an unsized vector,
--   its contents will be the <i>sized</i> vector counterpart.
--   
--   <pre>
--   testFunc :: Unsized.Vector Int -&gt; Int
--   testFunc (<a>SomeSized</a> v) =
--       <a>sum</a> (<a>zipWith</a> (+) v (<a>replicate</a> 1))
--           -- ^ here, v is `Sized.Vector n Int`, and we have
--                       `<a>KnownNat</a> n`
--   </pre>
--   
--   The <tt>n</tt> type variable will be properly instantiated to whatever
--   the length of the vector is, and you will also have a
--   <tt><a>KnownNat</a> n</tt> instance available. You can get <tt>n</tt>
--   in scope by turning on ScopedTypeVariables and matching on
--   <tt><a>SomeSized</a> (v :: Sized.Vector n Int)</tt>.
--   
--   Without this, you would otherwise have to use <a>withSized</a> to do
--   the same thing:
--   
--   <pre>
--   testFunc :: Unsized.Vector Int -&gt; Int
--   testFunc u = <a>withSized</a> u $ \v -&gt;
--       <a>sum</a> (<a>zipWith</a> (+) v (<a>replicate</a> 1))
--   </pre>
--   
--   Remember that the type of final result of your function (the
--   <tt>Int</tt>, here) must <i>not</i> depend on <tt>n</tt>. However, the
--   types of the intermediate values are allowed to depend on <tt>n</tt>.
--   
--   This is <i>especially</i> useful in do blocks, where you can pattern
--   match on the unsized results of actions, to use the sized vector in
--   the rest of the do block. You also get a <tt><a>KnownNat</a> n</tt>
--   constraint for the remainder of the do block.
--   
--   <pre>
--   -- If you had:
--   getAVector :: IO (Unsized.Vector Int)
--   
--   main :: IO ()
--   main = do
--       SomeSized v &lt;- getAVector -- v is `Sized.Vector n Int`
--       -- get n in scope
--       SomeSized (v :: Sized.Vector n Int) &lt;- getAVector
--       print v
--   </pre>
--   
--   Remember that the final type of the result of the do block
--   (<tt>()</tt>, here) must not depend on <tt>n</tt>. However, the
--   
--   Also useful in ghci, where you can pattern match to get sized vectors
--   from unsized vectors.
--   
--   <pre>
--   ghci&gt; SomeSized v &lt;- pure (myUnsizedVector :: Unsized.Vector Int)
--                -- ^ v is `Sized.Vector n Int`
--   </pre>
--   
--   This enables interactive exploration with sized vectors in ghci, and
--   is useful for using with other libraries and functions that expect
--   sized vectors in an interactive setting.
--   
--   (Note that as of GHC 8.6, you cannot get the <tt>n</tt> in scope in
--   your ghci session using ScopedTypeVariables, like you can with do
--   blocks)
--   
--   You can also use this as a constructor, to take a sized vector and
--   "hide" the size, to produce an unsized vector:
--   
--   <pre>
--   SomeSized :: Sized.Vector n a -&gt; Unsized.Vector a
--   </pre>
pattern SomeSized :: Unbox a => KnownNat n => Vector n a -> Vector a

-- | <a>Vector</a> specialized to use <a>Mutable</a>.
type MVector = MVector MVector

-- | <i>O(1)</i> Yield the length of the vector as an <a>Int</a>. This is
--   more like <a>natVal</a> than <a>length</a>, extracting the value from
--   the <a>KnownNat</a> instance and not looking at the vector itself.
length :: forall n a. KnownNat n => Vector n a -> Int

-- | <i>O(1)</i> Yield the length of the vector as a <a>Proxy</a>. This
--   function doesn't <i>do</i> anything; it merely allows the size
--   parameter of the vector to be passed around as a <a>Proxy</a>.
length' :: forall n a. Vector n a -> Proxy n

-- | <i>O(1)</i> Reveal a <a>KnownNat</a> instance for a vector's length,
--   determined at runtime.
knownLength :: forall n a r. Unbox a => Vector n a -> (KnownNat n => r) -> r

-- | <i>O(1)</i> Reveal a <a>KnownNat</a> instance and <a>Proxy</a> for a
--   vector's length, determined at runtime.
knownLength' :: forall n a r. Unbox a => Vector n a -> (KnownNat n => Proxy n -> r) -> r

-- | <i>O(1)</i> Safe indexing using a <a>Finite</a>.
index :: forall n a. Unbox a => Vector n a -> Finite n -> a

-- | <i>O(1)</i> Safe indexing using a <a>Proxy</a>.
index' :: forall n m a p. (KnownNat n, Unbox a) => Vector ((n + m) + 1) a -> p n -> a

-- | <i>O(1)</i> Indexing using an <a>Int</a> without bounds checking.
unsafeIndex :: forall n a. Unbox a => Vector n a -> Int -> a

-- | <i>O(1)</i> Yield the first element of a non-empty vector.
head :: forall n a. Unbox a => Vector (1 + n) a -> a

-- | <i>O(1)</i> Yield the last element of a non-empty vector.
last :: forall n a. Unbox a => Vector (n + 1) a -> a

-- | <i>O(1)</i> Safe indexing in a monad. See the documentation for
--   <a>indexM</a> for an explanation of why this is useful.
indexM :: forall n a m. (Unbox a, Monad m) => Vector n a -> Finite n -> m a

-- | <i>O(1)</i> Safe indexing in a monad using a <a>Proxy</a>. See the
--   documentation for <a>indexM</a> for an explanation of why this is
--   useful.
indexM' :: forall n k a m p. (KnownNat n, Unbox a, Monad m) => Vector (n + k) a -> p n -> m a

-- | <i>O(1)</i> Indexing using an Int without bounds checking. See the
--   documentation for <a>indexM</a> for an explanation of why this is
--   useful.
unsafeIndexM :: forall n a m. (Unbox a, Monad m) => Vector n a -> Int -> m a

-- | <i>O(1)</i> Yield the first element of a non-empty vector in a monad.
--   See the documentation for <a>indexM</a> for an explanation of why this
--   is useful.
headM :: forall n a m. (Unbox a, Monad m) => Vector (1 + n) a -> m a

-- | <i>O(1)</i> Yield the last element of a non-empty vector in a monad.
--   See the documentation for <a>indexM</a> for an explanation of why this
--   is useful.
lastM :: forall n a m. (Unbox a, Monad m) => Vector (n + 1) a -> m a

-- | <i>O(1)</i> Yield a slice of the vector without copying it with an
--   inferred length argument.
slice :: forall i n m a p. (KnownNat i, KnownNat n, Unbox a) => p i -> Vector ((i + n) + m) a -> Vector n a

-- | <i>O(1)</i> Yield a slice of the vector without copying it with an
--   explicit length argument.
slice' :: forall i n m a p. (KnownNat i, KnownNat n, Unbox a) => p i -> p n -> Vector ((i + n) + m) a -> Vector n a

-- | <i>O(1)</i> Yield all but the last element of a non-empty vector
--   without copying.
init :: forall n a. Unbox a => Vector (n + 1) a -> Vector n a

-- | <i>O(1)</i> Yield all but the first element of a non-empty vector
--   without copying.
tail :: forall n a. Unbox a => Vector (1 + n) a -> Vector n a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is inferred from the type.
take :: forall n m a. (KnownNat n, Unbox a) => Vector (n + m) a -> Vector n a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements. The resulting vector
--   always contains this many elements. The length of the resulting vector
--   is given explicitly as a <a>Proxy</a> argument.
take' :: forall n m a p. (KnownNat n, Unbox a) => p n -> Vector (n + m) a -> Vector n a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is inferred from the type.
drop :: forall n m a. (KnownNat n, Unbox a) => Vector (n + m) a -> Vector m a

-- | <i>O(1)</i> Yield all but the the first <tt>n</tt> elements. The given
--   vector must contain at least this many elements. The length of the
--   resulting vector is givel explicitly as a <a>Proxy</a> argument.
drop' :: forall n m a p. (KnownNat n, Unbox a) => p n -> Vector (n + m) a -> Vector m a

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The lengths of the resulting vector are inferred from
--   the type.
splitAt :: forall n m a. (KnownNat n, Unbox a) => Vector (n + m) a -> (Vector n a, Vector m a)

-- | <i>O(1)</i> Yield the first <tt>n</tt> elements, paired with the rest,
--   without copying. The length of the first resulting vector is passed
--   explicitly as a <a>Proxy</a> argument.
splitAt' :: forall n m a p. (KnownNat n, Unbox a) => p n -> Vector (n + m) a -> (Vector n a, Vector m a)

-- | <i>O(1)</i> Empty vector.
empty :: forall a. Unbox a => Vector 0 a

-- | <i>O(1)</i> Vector with exactly one element.
singleton :: forall a. Unbox a => a -> Vector 1 a

-- | <i>O(n)</i> Construct a vector in a type safe manner <tt> fromTuple
--   (1,2) :: Vector 2 Int fromTuple ("hey", "what's", "going", "on") ::
--   Vector 4 String </tt>
fromTuple :: forall a input length. (Unbox a, IndexedListLiterals input length a, KnownNat length) => input -> Vector length a

-- | <i>O(n)</i> Construct a vector with the same element in each position
--   where the length is inferred from the type.
replicate :: forall n a. (KnownNat n, Unbox a) => a -> Vector n a

-- | <i>O(n)</i> Construct a vector with the same element in each position
--   where the length is given explicitly as a <a>Proxy</a> argument.
replicate' :: forall n a p. (KnownNat n, Unbox a) => p n -> a -> Vector n a

-- | <i>O(n)</i> construct a vector of the given length by applying the
--   function to each index where the length is inferred from the type.
generate :: forall n a. (KnownNat n, Unbox a) => (Finite n -> a) -> Vector n a

-- | <i>O(n)</i> construct a vector of the given length by applying the
--   function to each index where the length is given explicitly as a
--   <a>Proxy</a> argument.
generate' :: forall n a p. (KnownNat n, Unbox a) => p n -> (Finite n -> a) -> Vector n a

-- | <i>O(n)</i> Apply the function <tt>n</tt> times to a value. Zeroth
--   element is original value. The length is inferred from the type.
iterateN :: forall n a. (KnownNat n, Unbox a) => (a -> a) -> a -> Vector n a

-- | <i>O(n)</i> Apply the function <tt>n</tt> times to a value. Zeroth
--   element is original value. The length is given explicitly as a
--   <a>Proxy</a> argument.
iterateN' :: forall n a p. (KnownNat n, Unbox a) => p n -> (a -> a) -> a -> Vector n a

-- | <i>O(n)</i> Execute the monadic action <tt>n</tt> times and store the
--   results in a vector where <tt>n</tt> is inferred from the type.
replicateM :: forall n m a. (KnownNat n, Unbox a, Monad m) => m a -> m (Vector n a)

-- | <i>O(n)</i> Execute the monadic action <tt>n</tt> times and store the
--   results in a vector where <tt>n</tt> is given explicitly as a
--   <a>Proxy</a> argument.
replicateM' :: forall n m a p. (KnownNat n, Unbox a, Monad m) => p n -> m a -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector of length <tt>n</tt> by applying the
--   monadic action to each index where <tt>n</tt> is inferred from the
--   type.
generateM :: forall n m a. (KnownNat n, Unbox a, Monad m) => (Finite n -> m a) -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector of length <tt>n</tt> by applying the
--   monadic action to each index where <tt>n</tt> is given explicitly as a
--   <a>Proxy</a> argument.
generateM' :: forall n m a p. (KnownNat n, Unbox a, Monad m) => p n -> (Finite n -> m a) -> m (Vector n a)

-- | <i>O(n)</i> Construct a vector with exactly <tt>n</tt> elements by
--   repeatedly applying the generator function to the a seed. The length
--   is inferred from the type.
unfoldrN :: forall n a b. (KnownNat n, Unbox a) => (b -> (a, b)) -> b -> Vector n a

-- | <i>O(n)</i> Construct a vector with exactly <tt>n</tt> elements by
--   repeatedly applying the generator function to the a seed. The length
--   is given explicitly as a <a>Proxy</a> argument.
unfoldrN' :: forall n a b p. (KnownNat n, Unbox a) => p n -> (b -> (a, b)) -> b -> Vector n a

-- | <i>O(n)</i> Yield a vector of length <tt>n</tt> containing the values
--   <tt>x</tt>, <tt>x+1</tt>, ..., <tt>x + (n - 1)</tt>. The length is
--   inferred from the type.
enumFromN :: forall n a. (KnownNat n, Unbox a, Num a) => a -> Vector n a

-- | <i>O(n)</i> Yield a vector of length <tt>n</tt> containing the values
--   <tt>x</tt>, <tt>x+1</tt>, ..., <tt>x + (n - 1)</tt>. The length is
--   given explicitly as a <a>Proxy</a> argument.
enumFromN' :: forall n a p. (KnownNat n, Unbox a, Num a) => a -> p n -> Vector n a

-- | <i>O(n)</i> Yield a vector of the given length containing the values
--   <tt>x</tt>, <tt>x+y</tt>, <tt>x+2y</tt>, ..., <tt>x + (n - 1)y</tt>.
--   The length is inferred from the type.
enumFromStepN :: forall n a. (KnownNat n, Unbox a, Num a) => a -> a -> Vector n a

-- | <i>O(n)</i> Yield a vector of the given length containing the values
--   <tt>x</tt>, <tt>x+y</tt>, <tt>x+2y</tt>, ..., <tt>x + (n - 1)y</tt>.
--   The length is given explicitly as a <a>Proxy</a> argument.
enumFromStepN' :: forall n a p. (KnownNat n, Unbox a, Num a) => a -> a -> p n -> Vector n a

-- | <i>O(n)</i> Prepend an element.
cons :: forall n a. Unbox a => a -> Vector n a -> Vector (1 + n) a

-- | <i>O(n)</i> Append an element.
snoc :: forall n a. Unbox a => Vector n a -> a -> Vector (n + 1) a

-- | <i>O(m+n)</i> Concatenate two vectors.
(++) :: forall n m a. Unbox a => Vector n a -> Vector m a -> Vector (n + m) a

-- | <i>O(n)</i> Yield the argument but force it not to retain any extra
--   memory, possibly by copying it.
--   
--   This is especially useful when dealing with slices. For example:
--   
--   <pre>
--   force (slice 0 2 &lt;huge vector&gt;)
--   </pre>
--   
--   Here, the slice retains a reference to the huge vector. Forcing it
--   creates a copy of just the elements that belong to the slice and
--   allows the huge vector to be garbage collected.
force :: Unbox a => Vector n a -> Vector n a

-- | <i>O(m+n)</i> For each pair <tt>(i,a)</tt> from the list, replace the
--   vector element at position <tt>i</tt> by <tt>a</tt>.
--   
--   <pre>
--   &lt;5,9,2,7&gt; // [(2,1),(0,3),(2,8)] = &lt;3,9,8,7&gt;
--   </pre>
(//) :: Unbox a => Vector m a -> [(Finite m, a)] -> Vector m a

-- | <i>O(m+n)</i> For each pair <tt>(i,a)</tt> from the vector of
--   index/value pairs, replace the vector element at position <tt>i</tt>
--   by <tt>a</tt>.
--   
--   <pre>
--   update &lt;5,9,2,7&gt; &lt;(2,1),(0,3),(2,8)&gt; = &lt;3,9,8,7&gt;
--   </pre>
update :: Unbox a => Vector m a -> Vector n (Int, a) -> Vector m a

-- | <i>O(m+n)</i> For each index <tt>i</tt> from the index vector and the
--   corresponding value <tt>a</tt> from the value vector, replace the
--   element of the initial vector at position <tt>i</tt> by <tt>a</tt>.
--   
--   <pre>
--   update_ &lt;5,9,2,7&gt;  &lt;2,0,2&gt; &lt;1,3,8&gt; = &lt;3,9,8,7&gt;
--   </pre>
--   
--   This function is useful for instances of <a>Vector</a> that cannot
--   store pairs. Otherwise, <a>update</a> is probably more convenient.
--   
--   <pre>
--   update_ xs is ys = <a>update</a> xs (<a>zip</a> is ys)
--   </pre>
update_ :: Unbox a => Vector m a -> Vector n Int -> Vector n a -> Vector m a

-- | Same as (<a>//</a>) but without bounds checking.
unsafeUpd :: Unbox a => Vector m a -> [(Int, a)] -> Vector m a

-- | Same as <a>update</a> but without bounds checking.
unsafeUpdate :: Unbox a => Vector m a -> Vector n (Int, a) -> Vector m a

-- | Same as <a>update_</a> but without bounds checking.
unsafeUpdate_ :: Unbox a => Vector m a -> Vector n Int -> Vector n a -> Vector m a

-- | <i>O(m+n)</i> For each pair <tt>(i,b)</tt> from the list, replace the
--   vector element <tt>a</tt> at position <tt>i</tt> by <tt>f a b</tt>.
--   
--   <pre>
--   accum (+) &lt;5,9,2&gt; [(2,4),(1,6),(0,3),(1,7)] = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
accum :: Unbox a => (a -> b -> a) -> Vector m a -> [(Finite m, b)] -> Vector m a

-- | <i>O(m+n)</i> For each pair <tt>(i,b)</tt> from the vector of pairs,
--   replace the vector element <tt>a</tt> at position <tt>i</tt> by <tt>f
--   a b</tt>.
--   
--   <pre>
--   accumulate (+) &lt;5,9,2&gt; &lt;(2,4),(1,6),(0,3),(1,7)&gt; = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
accumulate :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector m a -> Vector n (Int, b) -> Vector m a

-- | <i>O(m+n)</i> For each index <tt>i</tt> from the index vector and the
--   corresponding value <tt>b</tt> from the the value vector, replace the
--   element of the initial vector at position <tt>i</tt> by <tt>f a
--   b</tt>.
--   
--   <pre>
--   accumulate_ (+) &lt;5,9,2&gt; &lt;2,1,0,1&gt; &lt;4,6,3,7&gt; = &lt;5+3, 9+6+7, 2+4&gt;
--   </pre>
--   
--   This function is useful for instances of <a>Vector</a> that cannot
--   store pairs. Otherwise, <a>accumulate</a> is probably more convenient:
--   
--   <pre>
--   accumulate_ f as is bs = <a>accumulate</a> f as (<a>zip</a> is bs)
--   </pre>
accumulate_ :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector m a -> Vector n Int -> Vector n b -> Vector m a

-- | Same as <a>accum</a> but without bounds checking.
unsafeAccum :: Unbox a => (a -> b -> a) -> Vector m a -> [(Int, b)] -> Vector m a

-- | Same as <a>accumulate</a> but without bounds checking.
unsafeAccumulate :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector m a -> Vector n (Int, b) -> Vector m a

-- | Same as <a>accumulate_</a> but without bounds checking.
unsafeAccumulate_ :: (Unbox a, Unbox b) => (a -> b -> a) -> Vector m a -> Vector n Int -> Vector n b -> Vector m a

-- | <i>O(n)</i> Reverse a vector.
reverse :: Unbox a => Vector n a -> Vector n a

-- | <i>O(n)</i> Yield the vector obtained by replacing each element
--   <tt>i</tt> of the index vector by <tt>xs<tt>!</tt>i</tt>. This is
--   equivalent to <tt><a>map</a> (xs<tt>!</tt>) is</tt> but is often much
--   more efficient.
--   
--   <pre>
--   backpermute &lt;a,b,c,d&gt; &lt;0,3,2,3,1,0&gt; = &lt;a,d,c,d,b,a&gt;
--   </pre>
backpermute :: Unbox a => Vector m a -> Vector n Int -> Vector n a

-- | Same as <a>backpermute</a> but without bounds checking.
unsafeBackpermute :: Unbox a => Vector m a -> Vector n Int -> Vector n a

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) an arbitrary
--   element by its index.
ix :: forall n a f. (Unbox a, Functor f) => Finite n -> (a -> f a) -> Vector n a -> f (Vector n a)

-- | Type-safe lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) an
--   arbitrary element by its index which should be supplied via
--   TypeApplications.
ix' :: forall i n a f. (Unbox a, Functor f, KnownNat i, KnownNat n, (i + 1) <= n) => (a -> f a) -> Vector n a -> f (Vector n a)

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) the first
--   element of a non-empty vector.
_head :: forall n a f. (Unbox a, Functor f) => (a -> f a) -> Vector (1 + n) a -> f (Vector (1 + n) a)

-- | Lens to access (<i>O(1)</i>) and update (<i>O(n)</i>) the last element
--   of a non-empty vector.
_last :: forall n a f. (Unbox a, Functor f) => (a -> f a) -> Vector (n + 1) a -> f (Vector (n + 1) a)

-- | <i>O(n)</i> Pair each element in a vector with its index.
indexed :: (Unbox a, Unbox (Finite n)) => Vector n a -> Vector n (Finite n, a)

-- | <i>O(n)</i> Map a function over a vector.
map :: (Unbox a, Unbox b) => (a -> b) -> Vector n a -> Vector n b

-- | <i>O(n)</i> Apply a function to every element of a vector and its
--   index.
imap :: (Unbox a, Unbox b) => (Finite n -> a -> b) -> Vector n a -> Vector n b

-- | <i>O(n*m)</i> Map a function over a vector and concatenate the
--   results. The function is required to always return the same length
--   vector.
concatMap :: (Unbox a, Unbox b) => (a -> Vector m b) -> Vector n a -> Vector (n * m) b

-- | <i>O(n)</i> Apply the monadic action to all elements of the vector,
--   yielding a vector of results.
mapM :: (Monad m, Unbox a, Unbox b) => (a -> m b) -> Vector n a -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to every element of a vector and
--   its index, yielding a vector of results.
imapM :: (Monad m, Unbox a, Unbox b) => (Finite n -> a -> m b) -> Vector n a -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to all elements of a vector and
--   ignore the results.
mapM_ :: (Monad m, Unbox a) => (a -> m b) -> Vector n a -> m ()

-- | <i>O(n)</i> Apply the monadic action to every element of a vector and
--   its index, ignoring the results.
imapM_ :: (Monad m, Unbox a) => (Finite n -> a -> m b) -> Vector n a -> m ()

-- | <i>O(n)</i> Apply the monadic action to all elements of the vector,
--   yielding a vector of results. Equvalent to <tt>flip <a>mapM</a></tt>.
forM :: (Monad m, Unbox a, Unbox b) => Vector n a -> (a -> m b) -> m (Vector n b)

-- | <i>O(n)</i> Apply the monadic action to all elements of a vector and
--   ignore the results. Equivalent to <tt>flip <a>mapM_</a></tt>.
forM_ :: (Monad m, Unbox a) => Vector n a -> (a -> m b) -> m ()

-- | <i>O(n)</i> Zip two vectors of the same length with the given
--   function.
zipWith :: (Unbox a, Unbox b, Unbox c) => (a -> b -> c) -> Vector n a -> Vector n b -> Vector n c

-- | Zip three vectors with the given function.
zipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => (a -> b -> c -> d) -> Vector n a -> Vector n b -> Vector n c -> Vector n d
zipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
zipWith5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => (a -> b -> c -> d -> e -> f) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f
zipWith6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => (a -> b -> c -> d -> e -> f -> g) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n g

-- | <i>O(n)</i> Zip two vectors of the same length with a function that
--   also takes the elements' indices).
izipWith :: (Unbox a, Unbox b, Unbox c) => (Finite n -> a -> b -> c) -> Vector n a -> Vector n b -> Vector n c
izipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d) => (Finite n -> a -> b -> c -> d) -> Vector n a -> Vector n b -> Vector n c -> Vector n d
izipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (Finite n -> a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
izipWith5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => (Finite n -> a -> b -> c -> d -> e -> f) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f
izipWith6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) => (Finite n -> a -> b -> c -> d -> e -> f -> g) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n g

-- | <i>O(n)</i> Zip two vectors of the same length.
zip :: (Unbox a, Unbox b) => Vector n a -> Vector n b -> Vector n (a, b)
zip3 :: (Unbox a, Unbox b, Unbox c) => Vector n a -> Vector n b -> Vector n c -> Vector n (a, b, c)
zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n (a, b, c, d)
zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n (a, b, c, d, e)
zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n (a, b, c, d, e, f)

-- | <i>O(n)</i> Zip the two vectors of the same length with the monadic
--   action and yield a vector of results.
zipWithM :: (Monad m, Unbox a, Unbox b, Unbox c) => (a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)

-- | <i>O(n)</i> Zip the two vectors with a monadic action that also takes
--   the element index and yield a vector of results.
izipWithM :: (Monad m, Unbox a, Unbox b, Unbox c) => (Finite n -> a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)

-- | <i>O(n)</i> Zip the two vectors with the monadic action and ignore the
--   results.
zipWithM_ :: (Monad m, Unbox a, Unbox b) => (a -> b -> m c) -> Vector n a -> Vector n b -> m ()

-- | <i>O(n)</i> Zip the two vectors with a monadic action that also takes
--   the element index and ignore the results.
izipWithM_ :: (Monad m, Unbox a, Unbox b) => (Finite n -> a -> b -> m c) -> Vector n a -> Vector n b -> m ()

-- | <i>O(min(m,n))</i> Unzip a vector of pairs.
unzip :: (Unbox a, Unbox b) => Vector n (a, b) -> (Vector n a, Vector n b)
unzip3 :: (Unbox a, Unbox b, Unbox c) => Vector n (a, b, c) -> (Vector n a, Vector n b, Vector n c)
unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector n (a, b, c, d) -> (Vector n a, Vector n b, Vector n c, Vector n d)
unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector n (a, b, c, d, e) -> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e)
unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector n (a, b, c, d, e, f) -> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e, Vector n f)

-- | <i>O(n)</i> Check if the vector contains an element.
elem :: (Unbox a, Eq a) => a -> Vector n a -> Bool
infix 4 `elem`

-- | <i>O(n)</i> Check if the vector does not contain an element (inverse
--   of <a>elem</a>).
notElem :: (Unbox a, Eq a) => a -> Vector n a -> Bool
infix 4 `notElem`

-- | <i>O(n)</i> Yield <a>Just</a> the first element matching the predicate
--   or <a>Nothing</a> if no such element exists.
find :: Unbox a => (a -> Bool) -> Vector n a -> Maybe a

-- | <i>O(n)</i> Yield <a>Just</a> the index of the first element matching
--   the predicate or <a>Nothing</a> if no such element exists.
findIndex :: Unbox a => (a -> Bool) -> Vector n a -> Maybe (Finite n)

-- | <i>O(n)</i> Yield <a>Just</a> the index of the first occurence of the
--   given element or <a>Nothing</a> if the vector does not contain the
--   element. This is a specialised version of <a>findIndex</a>.
elemIndex :: (Unbox a, Eq a) => a -> Vector n a -> Maybe (Finite n)

-- | <i>O(n)</i> Left fold.
foldl :: Unbox b => (a -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold on non-empty vectors.
foldl1 :: Unbox a => (a -> a -> a) -> Vector (1 + n) a -> a

-- | <i>O(n)</i> Left fold with strict accumulator.
foldl' :: Unbox b => (a -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold on non-empty vectors with strict accumulator.
foldl1' :: Unbox a => (a -> a -> a) -> Vector (1 + n) a -> a

-- | <i>O(n)</i> Right fold.
foldr :: Unbox a => (a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold on non-empty vectors.
foldr1 :: Unbox a => (a -> a -> a) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Right fold with a strict accumulator.
foldr' :: Unbox a => (a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold on non-empty vectors with strict accumulator.
foldr1' :: Unbox a => (a -> a -> a) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Left fold (function applied to each element and its
--   index).
ifoldl :: Unbox b => (a -> Finite n -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Left fold with strict accumulator (function applied to
--   each element and its index).
ifoldl' :: Unbox b => (a -> Finite n -> b -> a) -> a -> Vector n b -> a

-- | <i>O(n)</i> Right fold (function applied to each element and its
--   index).
ifoldr :: Unbox a => (Finite n -> a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Right fold with strict accumulator (function applied to
--   each element and its index).
ifoldr' :: Unbox a => (Finite n -> a -> b -> b) -> b -> Vector n a -> b

-- | <i>O(n)</i> Check if all elements satisfy the predicate.
all :: Unbox a => (a -> Bool) -> Vector n a -> Bool

-- | <i>O(n)</i> Check if any element satisfies the predicate.
any :: Unbox a => (a -> Bool) -> Vector n a -> Bool

-- | <i>O(n)</i> Check if all elements are <a>True</a>.
and :: Vector n Bool -> Bool

-- | <i>O(n)</i> Check if any element is <a>True</a>.
or :: Vector n Bool -> Bool

-- | <i>O(n)</i> Compute the sum of the elements.
sum :: (Unbox a, Num a) => Vector n a -> a

-- | <i>O(n)</i> Compute the product of the elements.
product :: (Unbox a, Num a) => Vector n a -> a

-- | <i>O(n)</i> Yield the maximum element of the non-empty vector.
maximum :: (Unbox a, Ord a) => Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the maximum element of the non-empty vector
--   according to the given comparison function.
maximumBy :: Unbox a => (a -> a -> Ordering) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the minimum element of the non-empty vector.
minimum :: (Unbox a, Ord a) => Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the minimum element of the non-empty vector
--   according to the given comparison function.
minimumBy :: Unbox a => (a -> a -> Ordering) -> Vector (n + 1) a -> a

-- | <i>O(n)</i> Yield the index of the maximum element of the non-empty
--   vector.
maxIndex :: (Unbox a, Ord a) => Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the maximum element of the non-empty
--   vector according to the given comparison function.
maxIndexBy :: Unbox a => (a -> a -> Ordering) -> Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the minimum element of the non-empty
--   vector.
minIndex :: (Unbox a, Ord a) => Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Yield the index of the minimum element of the non-empty
--   vector according to the given comparison function.
minIndexBy :: Unbox a => (a -> a -> Ordering) -> Vector (n + 1) a -> Finite (n + 1)

-- | <i>O(n)</i> Monadic fold.
foldM :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold (action applied to each element and its
--   index).
ifoldM :: (Monad m, Unbox b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold over non-empty vectors.
fold1M :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector (1 + n) a -> m a

-- | <i>O(n)</i> Monadic fold with strict accumulator.
foldM' :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold with strict accumulator (action applied to
--   each element and its index).
ifoldM' :: (Monad m, Unbox b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a

-- | <i>O(n)</i> Monadic fold over non-empty vectors with strict
--   accumulator.
fold1M' :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector (n + 1) a -> m a

-- | <i>O(n)</i> Monadic fold that discards the result.
foldM_ :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold that discards the result (action applied to
--   each element and its index).
ifoldM_ :: (Monad m, Unbox b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold over non-empty vectors that discards the
--   result.
fold1M_ :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector (n + 1) a -> m ()

-- | <i>O(n)</i> Monadic fold with strict accumulator that discards the
--   result.
foldM'_ :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monadic fold with strict accumulator that discards the
--   result (action applied to each element and its index).
ifoldM'_ :: (Monad m, Unbox b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()

-- | <i>O(n)</i> Monad fold over non-empty vectors with strict accumulator
--   that discards the result.
fold1M'_ :: (Monad m, Unbox a) => (a -> a -> m a) -> Vector (n + 1) a -> m ()

-- | Evaluate each action and collect the results.
sequence :: (Monad m, Unbox a, Unbox (m a)) => Vector n (m a) -> m (Vector n a)

-- | Evaluate each action and discard the results.
sequence_ :: (Monad m, Unbox (m a)) => Vector n (m a) -> m ()

-- | <i>O(n)</i> Prescan.
--   
--   <pre>
--   prescanl f z = <a>init</a> . <a>scanl</a> f z
--   </pre>
--   
--   Example: <tt>prescanl (+) 0 &lt;1,2,3,4&gt; = &lt;0,1,3,6&gt;</tt>
prescanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Prescan with strict accumulator.
prescanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Scan.
postscanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Scan with strict accumulator.
postscanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector n a

-- | <i>O(n)</i> Haskell-style scan.
scanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector (1 + n) a

-- | <i>O(n)</i> Haskell-style scan with strict accumulator.
scanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector (1 + n) a

-- | <i>O(n)</i> Scan over a non-empty vector.
scanl1 :: Unbox a => (a -> a -> a) -> Vector (1 + n) a -> Vector (2 + n) a

-- | <i>O(n)</i> Scan over a non-empty vector with a strict accumulator.
scanl1' :: Unbox a => (a -> a -> a) -> Vector (1 + n) a -> Vector (2 + n) a

-- | <i>O(n)</i> Right-to-left prescan.
prescanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left prescan with strict accumulator.
prescanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left scan.
postscanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left scan with strict accumulator.
postscanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector n b

-- | <i>O(n)</i> Right-to-left Haskell-style scan.
scanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector (n + 1) b

-- | <i>O(n)</i> Right-to-left Haskell-style scan with strict accumulator.
scanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector (n + 1) b

-- | <i>O(n)</i> Right-to-left scan over a non-empty vector.
scanr1 :: Unbox a => (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 2) a

-- | <i>O(n)</i> Right-to-left scan over a non-empty vector with a strict
--   accumulator.
scanr1' :: Unbox a => (a -> a -> a) -> Vector (n + 1) a -> Vector (n + 2) a

-- | <i>O(n)</i> Convert a vector to a list.
toList :: Unbox a => Vector n a -> [a]

-- | <i>O(n)</i> Convert a list to a vector.
fromList :: (Unbox a, KnownNat n) => [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Convert the first <tt>n</tt> elements of a list to a
--   vector. The length of the resulting vector is inferred from the type.
fromListN :: forall n a. (Unbox a, KnownNat n) => [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Convert the first <tt>n</tt> elements of a list to a
--   vector. The length of the resulting vector is given explicitly as a
--   <a>Proxy</a> argument.
fromListN' :: forall n a p. (Unbox a, KnownNat n) => p n -> [a] -> Maybe (Vector n a)

-- | <i>O(n)</i> Takes a list and returns a continuation providing a vector
--   with a size parameter corresponding to the length of the list.
--   
--   Essentially converts a list into a vector with the proper size
--   parameter, determined at runtime.
--   
--   See <a>withSized</a>
withSizedList :: forall a r. Unbox a => [a] -> (forall n. KnownNat n => Vector n a -> r) -> r

-- | <i>O(n)</i> Yield an immutable copy of the mutable vector.
freeze :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> m (Vector n a)

-- | <i>O(n)</i> Yield a mutable copy of the immutable vector.
thaw :: (PrimMonad m, Unbox a) => Vector n a -> m (MVector n (PrimState m) a)

-- | <i>O(n)</i> Copy an immutable vector into a mutable one.
copy :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> Vector n a -> m ()

-- | <i>O(1)</i> Unsafely convert a mutable vector to an immutable one
--   withouy copying. The mutable vector may not be used after this
--   operation.
unsafeFreeze :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> m (Vector n a)

-- | <i>O(n)</i> Unsafely convert an immutable vector to a mutable one
--   without copying. The immutable vector may not be used after this
--   operation.
unsafeThaw :: (PrimMonad m, Unbox a) => Vector n a -> m (MVector n (PrimState m) a)

-- | Convert a <a>Vector</a> into a <a>Vector</a> if it has the correct
--   size, otherwise return <a>Nothing</a>.
toSized :: forall n a. (Unbox a, KnownNat n) => Vector a -> Maybe (Vector n a)

-- | Takes a <a>Vector</a> and returns a continuation providing a
--   <a>Vector</a> with a size parameter <tt>n</tt> that is determined at
--   runtime based on the length of the input vector.
--   
--   Essentially converts a <a>Vector</a> into a <a>Vector</a> with the
--   correct size parameter <tt>n</tt>.
withSized :: forall a r. Unbox a => Vector a -> (forall n. KnownNat n => Vector n a -> r) -> r
fromSized :: Vector n a -> Vector a

-- | Apply a function on unsized vectors to a sized vector. The function
--   must preserve the size of the vector, this is not checked.
withVectorUnsafe :: forall a b (n :: Nat). () => (Vector a -> Vector b) -> Vector n a -> Vector n b

-- | Apply a function on two unsized vectors to sized vectors. The function
--   must preserve the size of the vectors, this is not checked.
zipVectorsUnsafe :: (Vector a -> Vector b -> Vector c) -> Vector n a -> Vector n b -> Vector n c
class (Vector Vector a, MVector MVector a) => Unbox a