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

-- | Non-empty vectors
--   
--   Performant, non-empty mutable and immutable vectors
@package nonempty-vector
@version 0.2.4

-- | Internal module exposing the constructors for NonEmptyVector
--   and NonEmptyMVector.
--   
--   Warning: Since the constructors are exposed here, by using this
--   module, you take on the risks that you break the non-emptiness
--   invariants of the main modules. Use at your own risk.
module Data.Vector.NonEmpty.Internal

-- | NonEmptyVector is a thin wrapper around Vector that
--   witnesses an API requiring non-empty construction, initialization, and
--   generation of non-empty vectors by design.
--   
--   A newtype wrapper was chosen so that no new pointer indirection is
--   introduced when working with Vectors, and all performance
--   characteristics inherited from the Vector API still apply.
newtype NonEmptyVector a
NonEmptyVector :: Vector a -> NonEmptyVector a
[_neVec] :: NonEmptyVector a -> Vector a

-- | NonEmptyMVector is a thin wrapper around MVector that
--   witnesses an API requiring non-empty construction, initialization, and
--   generation of non-empty vectors by design.
--   
--   A newtype wrapper was chosen so that no new pointer indirection is
--   introduced when working with MVectors, and all performance
--   characteristics inherited from the MVector API still apply.
newtype NonEmptyMVector s a
NonEmptyMVector :: MVector s a -> NonEmptyMVector s a
[_nemVec] :: NonEmptyMVector s a -> MVector s a

-- | NonEmptyMVector parametrized by PrimState
type NonEmptyIOVector = NonEmptyMVector RealWorld

-- | NonEmptyMVector parametrized by ST
type NonEmptySTVector s = NonEmptyMVector s
instance GHC.Internal.Base.Applicative Data.Vector.NonEmpty.Internal.NonEmptyVector
instance GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (Data.Vector.NonEmpty.Internal.NonEmptyVector a)
instance Data.Functor.Classes.Eq1 Data.Vector.NonEmpty.Internal.NonEmptyVector
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Vector.NonEmpty.Internal.NonEmptyVector a)
instance Data.Foldable1.Foldable1 Data.Vector.NonEmpty.Internal.NonEmptyVector
instance GHC.Internal.Data.Foldable.Foldable Data.Vector.NonEmpty.Internal.NonEmptyVector
instance GHC.Internal.Base.Functor Data.Vector.NonEmpty.Internal.NonEmptyVector
instance GHC.Internal.Base.Monad Data.Vector.NonEmpty.Internal.NonEmptyVector
instance Control.Monad.Zip.MonadZip Data.Vector.NonEmpty.Internal.NonEmptyVector
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Data.Vector.NonEmpty.Internal.NonEmptyVector a)
instance Data.Functor.Classes.Ord1 Data.Vector.NonEmpty.Internal.NonEmptyVector
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Vector.NonEmpty.Internal.NonEmptyVector a)
instance Data.Functor.Classes.Read1 Data.Vector.NonEmpty.Internal.NonEmptyVector
instance GHC.Internal.Read.Read a => GHC.Internal.Read.Read (Data.Vector.NonEmpty.Internal.NonEmptyVector a)
instance GHC.Internal.Base.Semigroup (Data.Vector.NonEmpty.Internal.NonEmptyVector a)
instance Data.Functor.Classes.Show1 Data.Vector.NonEmpty.Internal.NonEmptyVector
instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Vector.NonEmpty.Internal.NonEmptyVector a)
instance GHC.Internal.Data.Traversable.Traversable Data.Vector.NonEmpty.Internal.NonEmptyVector

-- | A library for non-empty boxed vectors (that is, polymorphic arrays
--   capable of holding any Haskell value). Non-empty vectors come in two
--   flavors:
--   
--   
--   
- mutable
--   
- immutable
--   
--   
--   This library attempts to provide support for all standard
--   Vector operations in the API, with some slight variation in
--   types and implementation. For example, since head and
--   foldr are always gauranteed to be over a non-empty
--   Vector, it is safe to make use of the 'unsafe-*' Vector
--   operations and semigroupal folds available in the API in lieu of the
--   standard implementations.
--   
--   In contrast, some operations such as filter may "break out" of
--   a NonEmptyVector due to the fact that there are no guarantees
--   that may be made on the types of Bool-valued functions passed
--   in, hence one could write the following:
--   
--   
--   filter (const false) v
--   
--   
--   which always produces an empty vector. Thus, some operations must
--   return either a Maybe containing a NonEmptyVector or a
--   Vector whenever appropriate. Generally The former is used in
--   initialization and generation operations, and the latter is used in
--   iterative operations where the intent is not to create an instance of
--   NonEmptyVector.
--   
--   Credit to Roman Leshchinskiy for the original Vector library upon
--   which this is based.
module Data.Vector.NonEmpty

-- | NonEmptyVector is a thin wrapper around Vector that
--   witnesses an API requiring non-empty construction, initialization, and
--   generation of non-empty vectors by design.
--   
--   A newtype wrapper was chosen so that no new pointer indirection is
--   introduced when working with Vectors, and all performance
--   characteristics inherited from the Vector API still apply.
data NonEmptyVector a

-- | O(1) Length.
--   
--   
--   >>> length $ unsafeFromList [1..10]
--   10
--   
length :: NonEmptyVector a -> Int

-- | O(1) First element. Since head is gauranteed, bounds checks are
--   bypassed by deferring to unsafeHead.
--   
--   
--   >>> head $ unsafeFromList [1..10]
--   1
--   
head :: NonEmptyVector a -> a

-- | O(1) Last element. Since a last element is gauranteed, bounds
--   checks are bypassed by deferring to unsafeLast.
--   
--   
--   >>> last $ unsafeFromList [1..10]
--   10
--   
last :: NonEmptyVector a -> a

-- | O(1) Indexing.
--   
--   
--   >>> (unsafeFromList [1..10]) ! 0
--   1
--   
(!) :: NonEmptyVector a -> Int -> a

-- | O(1) Safe indexing.
--   
--   
--   >>> (unsafeFromList [1..10]) !? 0
--   Just 1
--   
--   
--   
--   >>> (unsafeFromList [1..10]) !? 11
--   Nothing
--   
(!?) :: NonEmptyVector a -> Int -> Maybe a

-- | O(1) Unsafe indexing without bounds checking
unsafeIndex :: NonEmptyVector a -> Int -> a

-- | O(1) First element of a non-empty vector in a monad.
--   
--   See indexM for an explanation of why this is useful.
--   
--   Note that this function defers to unsafeHeadM since head is
--   gauranteed to be safe by construction.
--   
--   
--   >>> headM @[] (unsafeFromList [1..10])
--   [1]
--   
headM :: Monad m => NonEmptyVector a -> m a

-- | O(1) Last element of a non-empty vector in a monad. See
--   indexM for an explanation of why this is useful.
--   
--   Note that this function defers to unsafeHeadM since a last
--   element is gauranteed.
--   
--   
--   >>> lastM @[] (unsafeFromList [1..10])
--   [10]
--   
lastM :: Monad m => NonEmptyVector a -> m a

-- | O(1) Indexing in a monad.
--   
--   The monad allows operations to be strict in the non-empty vector when
--   necessary.
--   
--   See indexM for more details
--   
--   
--   >>> indexM @[] (unsafeFromList [1..10]) 3
--   [4]
--   
indexM :: Monad m => NonEmptyVector a -> Int -> m a

-- | O(1) Indexing in a monad without bounds checks. See indexM for
--   an explanation of why this is useful.
unsafeIndexM :: Monad m => NonEmptyVector a -> Int -> m a

-- | O(1) Yield all but the first element without copying. Since the
--   vector returned may be empty (i.e. input was a singleton), this
--   function returns a normal Vector
--   
--   
--   >>> tail (unsafeFromList [1..10])
--   [2,3,4,5,6,7,8,9,10]
--   
tail :: NonEmptyVector a -> Vector a

-- | O(1) Yield a slice of the non-empty vector without copying it.
--   The vector must contain at least i+n elements. Because this is not
--   guaranteed, this function returns a Vector which could be empty
--   
--   
--   >>> slice 0 3 (unsafeFromList [1..10])
--   [1,2,3]
--   
slice :: Int -> Int -> NonEmptyVector a -> Vector a

-- | O(1) Yield all but the last element without copying. Since the
--   vector returned may be empty (i.e. input was a singleton), this
--   function returns a normal Vector
--   
--   
--   >>> init (unsafeFromList [1..3])
--   [1,2]
--   
init :: NonEmptyVector a -> Vector a

-- | O(1) Yield at the first n elements without copying. The
--   non-empty vector may contain less than n elements in which case it is
--   returned as a vector unchanged.
--   
--   
--   >>> take 2 (unsafeFromList [1..3])
--   [1,2]
--   
take :: Int -> NonEmptyVector a -> Vector a

-- | O(1) Yield all but the first n elements without copying. The
--   non-empty vector may contain less than n elements in which case an
--   empty vector is returned.
--   
--   
--   >>> drop 2 (unsafeFromList [1..3])
--   [3]
--   
drop :: Int -> NonEmptyVector a -> Vector a

-- | O(1) Yield a slice of a non-empty vector without copying at the
--   0th and 1st indices.
--   
--   
--   >>> uncons (unsafeFromList [1..10])
--   (1,[2,3,4,5,6,7,8,9,10])
--   
uncons :: NonEmptyVector a -> (a, Vector a)

-- | O(1) Yield a slice of a non-empty vector without copying at the
--   n-1th and nth indices
--   
--   
--   >>> unsnoc (unsafeFromList [1..10])
--   ([1,2,3,4,5,6,7,8,9],10)
--   
unsnoc :: NonEmptyVector a -> (Vector a, a)

-- | O(1) Yield the first n elements paired with the remainder
--   without copying.
--   
--   This function returns a pair of vectors, as one may slice a (0, n+1).
--   
--   
--   >>> splitAt 2 (unsafeFromList [1..3])
--   ([1,2],[3])
--   
splitAt :: Int -> NonEmptyVector a -> (Vector a, Vector a)

-- | O(1) Yield a slice of the vector without copying. The vector
--   must contain at least i+n elements but this is not checked.
unsafeSlice :: Int -> Int -> NonEmptyVector a -> Vector a

-- | O(1) Yield the first n elements without copying. The vector
--   must contain at least n elements but this is not checked.
unsafeTake :: Int -> NonEmptyVector a -> Vector a

-- | O(1) Yield all but the first n elements without copying. The
--   vector must contain at least n elements but this is not checked.
unsafeDrop :: Int -> NonEmptyVector a -> Vector a

-- | O(1) Non-empty vector with exactly one element
--   
--   
--   >>> singleton "a"
--   ["a"]
--   
singleton :: a -> NonEmptyVector a

-- | O(n) Non-empty vector of the given length with the same value
--   in each position.
--   
--   When given a index n <= 0, then Nothing is returned,
--   otherwise Just.
--   
--   
--   >>> replicate 3 "a"
--   Just ["a","a","a"]
--   
--   
--   
--   >>> replicate 0 "a"
--   Nothing
--   
replicate :: Int -> a -> Maybe (NonEmptyVector a)

-- | O(n) Non-empty vector of the given length with the same value
--   in each position.
--   
--   This variant takes max n 1 for the supplied length parameter.
--   
--   
--   >>> replicate1 3 "a"
--   ["a","a","a"]
--   
--   
--   
--   >>> replicate1 0 "a"
--   ["a"]
--   
--   
--   
--   >>> replicate1 (-1) "a"
--   ["a"]
--   
replicate1 :: Int -> a -> NonEmptyVector a

-- | O(n) Construct a vector of the given length by applying the
--   function to each index.
--   
--   When given a index n <= 0, then Nothing is returned,
--   otherwise Just.
--   
--   
--   >>> let f 0 = "a"; f _ = "k"; f :: Int -> String
--   
--   
--   
--   >>> generate 1 f
--   Just ["a"]
--   
--   
--   
--   >>> generate 0 f
--   Nothing
--   
--   
--   
--   >>> generate 2 f
--   Just ["a","k"]
--   
generate :: Int -> (Int -> a) -> Maybe (NonEmptyVector a)

-- | O(n) Construct a vector of the given length by applying the
--   function to each index.
--   
--   This variant takes max n 1 for the supplied length parameter.
--   
--   
--   >>> let f 0 = "a"; f _ = "k"; f :: Int -> String
--   
--   
--   
--   >>> generate1 2 f
--   ["a","k"]
--   
--   
--   
--   >>> generate1 0 f
--   ["a"]
--   
--   
--   
--   >>> generate1 (-1) f
--   ["a"]
--   
generate1 :: Int -> (Int -> a) -> NonEmptyVector a

-- | O(n) Apply function n times to value. Zeroth element is
--   original value.
--   
--   When given a index n <= 0, then Nothing is returned,
--   otherwise Just.
--   
--   
--   >>> iterateN 3 (+1) 0
--   Just [0,1,2]
--   
--   
--   
--   >>> iterateN 0 (+1) 0
--   Nothing
--   
--   
--   
--   >>> iterateN (-1) (+1) 0
--   Nothing
--   
iterateN :: Int -> (a -> a) -> a -> Maybe (NonEmptyVector a)

-- | O(n) Apply function n times to value. Zeroth element is
--   original value.
--   
--   This variant takes max n 1 for the supplied length parameter.
--   
--   
--   >>> iterateN1 3 (+1) 0
--   [0,1,2]
--   
--   
--   
--   >>> iterateN1 0 (+1) 0
--   [0]
--   
--   
--   
--   >>> iterateN1 (-1) (+1) 0
--   [0]
--   
iterateN1 :: Int -> (a -> a) -> a -> NonEmptyVector a

-- | O(n) Execute the monadic action the given number of times and
--   store the results in a vector.
--   
--   When given a index n <= 0, then Nothing is returned,
--   otherwise Just.
--   
--   
--   >>> replicateM @Maybe 3 (Just "a")
--   Just (Just ["a","a","a"])
--   
--   
--   
--   >>> replicateM @Maybe 3 Nothing
--   Nothing
--   
--   
--   
--   >>> replicateM @Maybe 0 (Just "a")
--   Just Nothing
--   
--   
--   
--   >>> replicateM @Maybe (-1) (Just "a")
--   Just Nothing
--   
replicateM :: Monad m => Int -> m a -> m (Maybe (NonEmptyVector a))

-- | O(n) Execute the monadic action the given number of times and
--   store the results in a vector.
--   
--   This variant takes max n 1 for the supplied length parameter.
--   
--   
--   >>> replicate1M @Maybe 3 (Just "a")
--   Just ["a","a","a"]
--   
--   
--   
--   >>> replicate1M @Maybe 3 Nothing
--   Nothing
--   
--   
--   
--   >>> replicate1M @Maybe 0 (Just "a")
--   Just ["a"]
--   
--   
--   
--   >>> replicate1M @Maybe (-1) (Just "a")
--   Just ["a"]
--   
replicate1M :: Monad m => Int -> m a -> m (NonEmptyVector a)

-- | O(n) Construct a vector of the given length by applying the
--   monadic action to each index
--   
--   When given a index n <= 0, then Nothing is returned,
--   otherwise Just.
--   
--   
--   >>> generateM 3 (\i -> if i P.< 1 then ["a"] else ["b"])
--   [Just ["a","b","b"]]
--   
--   
--   
--   >>> generateM @[] @Int 3 (const [])
--   []
--   
--   
--   
--   >>> generateM @[] @Int 0 (const [1])
--   [Nothing]
--   
--   
--   
--   >>> generateM @Maybe @Int (-1) (const Nothing)
--   Just Nothing
--   
generateM :: Monad m => Int -> (Int -> m a) -> m (Maybe (NonEmptyVector a))

-- | O(n) Construct a vector of the given length by applying the
--   monadic action to each index
--   
--   This variant takes max n 1 for the supplied length parameter.
--   
--   
--   >>> generate1M 3 (\i -> if i P.< 1 then Just "a" else Just "b")
--   Just ["a","b","b"]
--   
--   
--   
--   >>> generate1M 3 (const [])
--   []
--   
--   
--   
--   >>> generate1M 0 (const $ Just 1)
--   Just [1]
--   
--   
--   
--   >>> generate1M (-1) (const Nothing)
--   Nothing
--   
generate1M :: Monad m => Int -> (Int -> m a) -> m (NonEmptyVector a)

-- | O(n) Apply monadic function n times to value. Zeroth element is
--   original value.
--   
--   When given a index n <= 0, then Nothing is returned,
--   otherwise Just.
--   
--   
--   >>> iterateNM @Maybe 3 return "a"
--   Just (Just ["a","a","a"])
--   
--   
--   
--   >>> iterateNM @Maybe 3 (const Nothing) "a"
--   Nothing
--   
--   
--   
--   >>> iterateNM @Maybe 0 return "a"
--   Just Nothing
--   
iterateNM :: Monad m => Int -> (a -> m a) -> a -> m (Maybe (NonEmptyVector a))

-- | O(n) Apply monadic function n times to value. Zeroth element is
--   original value.
--   
--   This variant takes max n 1 for the supplied length parameter.
--   
--   
--   >>> iterateN1M @Maybe 3 return "a"
--   Just ["a","a","a"]
--   
--   
--   
--   >>> iterateN1M @Maybe 3 (const Nothing) "a"
--   Nothing
--   
--   
--   
--   >>> iterateN1M @Maybe 0 return "a"
--   Just ["a"]
--   
--   
--   
--   >>> iterateN1M @Maybe (-1) return "a"
--   Just ["a"]
--   
iterateN1M :: Monad m => Int -> (a -> m a) -> a -> m (NonEmptyVector a)

-- | Execute the monadic action and freeze the resulting non-empty vector.
create :: (forall s. () => ST s (MVector s a)) -> Maybe (NonEmptyVector a)

-- | Execute the monadic action and freeze the resulting non-empty vector,
--   bypassing emptiness checks.
--   
--   The onus is on the caller to guarantee the created vector is
--   non-empty.
unsafeCreate :: (forall s. () => ST s (MVector s a)) -> NonEmptyVector a

-- | Execute the monadic action and freeze the resulting non-empty vector.
createT :: Traversable t => (forall s. () => ST s (t (MVector s a))) -> t (Maybe (NonEmptyVector a))

-- | Execute the monadic action and freeze the resulting non-empty vector.
--   
--   The onus is on the caller to guarantee the created vector is
--   non-empty.
unsafeCreateT :: Traversable t => (forall s. () => ST s (t (MVector s a))) -> t (NonEmptyVector a)

-- | O(n) Construct a non-empty vector by repeatedly applying the
--   generator function to a seed. The generator function yields
--   Just the next element and the new seed or Nothing if
--   there are no more elements.
--   
--   If an unfold does not create meaningful values, Nothing is
--   returned. Otherwise, Just containing a non-empty vector is
--   returned.
--   
--   
--   >>> unfoldr (\b -> case b of "a" -> Just ("a", "b"); _ ->  Nothing) "a"
--   Just ["a"]
--   
--   
--   
--   >>> unfoldr (const Nothing) "a"
--   Nothing
--   
unfoldr :: (b -> Maybe (a, b)) -> b -> Maybe (NonEmptyVector a)

-- | O(n) Construct a non-empty vector by repeatedly applying the
--   generator function to a seed and a first element.
--   
--   This variant of unfoldr guarantees the resulting vector is non-
--   empty by supplying an initial element a.
--   
--   
--   >>> unfoldr1 (\b -> case b of "a" -> Just ("a", "b"); _ ->  Nothing) "first" "a"
--   ["first","a"]
--   
--   
--   
--   >>> unfoldr1 (const Nothing) "first" "a"
--   ["first"]
--   
unfoldr1 :: (b -> Maybe (a, b)) -> a -> b -> NonEmptyVector a

-- | O(n) Construct a vector with at most n elements by repeatedly
--   applying the generator function to a seed. The generator function
--   yields Just the next element and the new seed or Nothing
--   if there are no more elements.
--   
--   If an unfold does not create meaningful values, Nothing is
--   returned. Otherwise, Just containing a non-empty vector is
--   returned.
--   
--   
--   >>> unfoldrN 3 (\b -> Just (b+1, b+1)) 0
--   Just [1,2,3]
--   
--   
--   
--   >>> unfoldrN 3 (const Nothing) 0
--   Nothing
--   
--   
--   
--   >>> unfoldrN 0 (\b -> Just (b+1, b+1)) 0
--   Nothing
--   
unfoldrN :: Int -> (b -> Maybe (a, b)) -> b -> Maybe (NonEmptyVector a)

-- | O(n) Construct a vector with at most n elements by repeatedly
--   applying the generator function to a seed. The generator function
--   yields Just the next element and the new seed or Nothing
--   if there are no more elements.
--   
--   This variant of unfoldrN guarantees the resulting vector is
--   non- empty by supplying an initial element a.
--   
--   
--   >>> unfoldr1N 3 (\b -> Just (b+1, b+1)) 0 0
--   [0,1,2,3]
--   
--   
--   
--   >>> unfoldr1N 3 (const Nothing) 0 0
--   [0]
--   
--   
--   
--   >>> unfoldr1N 0 (\b -> Just (b+1, b+1)) 0 0
--   [0]
--   
unfoldr1N :: Int -> (b -> Maybe (a, b)) -> a -> b -> NonEmptyVector a

-- | O(n) Construct a non-empty vector by repeatedly applying the
--   monadic generator function to a seed. The generator function yields
--   Just the next element and the new seed or Nothing if there are no more
--   elements.
--   
--   If an unfold does not create meaningful values, Nothing is
--   returned. Otherwise, Just containing a non-empty vector is
--   returned.
unfoldrM :: Monad m => (b -> m (Maybe (a, b))) -> b -> m (Maybe (NonEmptyVector a))

-- | O(n) Construct a non-empty vector by repeatedly applying the
--   monadic generator function to a seed. The generator function yields
--   Just the next element and the new seed or Nothing if there are no more
--   elements.
--   
--   This variant of unfoldrM guarantees the resulting vector is
--   non- empty by supplying an initial element a.
unfoldr1M :: Monad m => (b -> m (Maybe (a, b))) -> a -> b -> m (NonEmptyVector a)

-- | O(n) Construct a non-empty vector by repeatedly applying the
--   monadic generator function to a seed. The generator function yields
--   Just the next element and the new seed or Nothing if there are no more
--   elements.
--   
--   If an unfold does not create meaningful values, Nothing is
--   returned. Otherwise, Just containing a non-empty vector is
--   returned.
unfoldrNM :: Monad m => Int -> (b -> m (Maybe (a, b))) -> b -> m (Maybe (NonEmptyVector a))

-- | O(n) Construct a non-empty vector by repeatedly applying the
--   monadic generator function to a seed. The generator function yields
--   Just the next element and the new seed or Nothing if there are no more
--   elements.
--   
--   This variant of unfoldrNM guarantees the resulting vector is
--   non- empty by supplying an initial element a.
unfoldr1NM :: Monad m => Int -> (b -> m (Maybe (a, b))) -> a -> b -> m (NonEmptyVector a)

-- | O(n) Construct a non-empty vector with n elements by repeatedly
--   applying the generator function to the already constructed part of the
--   vector.
--   
--   If constructN does not create meaningful values, Nothing
--   is returned. Otherwise, Just containing a non-empty vector is
--   returned.
constructN :: Int -> (Vector a -> a) -> Maybe (NonEmptyVector a)

-- | O(n) Construct a vector with n elements from right to left by
--   repeatedly applying the generator function to the already constructed
--   part of the vector.
--   
--   If constructrN does not create meaningful values,
--   Nothing is returned. Otherwise, Just containing a
--   non-empty vector is returned.
constructrN :: Int -> (Vector a -> a) -> Maybe (NonEmptyVector a)

-- | O(n) Yield a non-emptyvector of the given length containing the
--   values x, x+1 etc. This operation is usually more efficient than
--   enumFromTo.
--   
--   If an enumeration does not use meaningful indices, Nothing is
--   returned, otherwise, Just containing a non-empty vector.
enumFromN :: Num a => a -> Int -> Maybe (NonEmptyVector a)

-- | O(n) Yield a non-emptyvector of length max n 1
--   containing the values x, x+1 etc. This operation is usually more
--   efficient than enumFromTo.
enumFromN1 :: Num a => a -> Int -> NonEmptyVector a

-- | O(n) Yield a non-empty vector of the given length containing
--   the values x, x+y, x+y+y etc. This operations is usually more
--   efficient than enumFromThenTo.
--   
--   If an enumeration does not use meaningful indices, Nothing is
--   returned, otherwise, Just containing a non-empty vector.
enumFromStepN :: Num a => a -> a -> Int -> Maybe (NonEmptyVector a)

-- | O(n) Yield a non-empty vector of length max n 1
--   containing the values x, x+y, x+y+y etc. This operations is usually
--   more efficient than enumFromThenTo.
enumFromStepN1 :: Num a => a -> a -> Int -> NonEmptyVector a

-- | O(n) Enumerate values from x to y.
--   
--   If an enumeration does not use meaningful indices, Nothing is
--   returned, otherwise, Just containing a non-empty vector.
--   
--   WARNING: This operation can be very inefficient. If at all
--   possible, use enumFromN instead.
enumFromTo :: Enum a => a -> a -> Maybe (NonEmptyVector a)

-- | O(n) Enumerate values from x to y with a specific step z.
--   
--   If an enumeration does not use meaningful indices, Nothing is
--   returned, otherwise, Just containing a non-empty vector.
--   
--   WARNING: This operation can be very inefficient. If at all
--   possible, use enumFromStepN instead.
enumFromThenTo :: Enum a => a -> a -> a -> Maybe (NonEmptyVector a)

-- | O(n) Prepend an element
--   
--   
--   >>> cons 1 (unsafeFromList [2,3])
--   [1,2,3]
--   
cons :: a -> NonEmptyVector a -> NonEmptyVector a

-- | O(n) Prepend an element to a Vector
--   
--   
--   >>> consV 1 (V.fromList [2,3])
--   [1,2,3]
--   
consV :: a -> Vector a -> NonEmptyVector a

-- | O(n) Append an element
--   
--   
--   >>> snoc (unsafeFromList [1,2]) 3
--   [1,2,3]
--   
snoc :: NonEmptyVector a -> a -> NonEmptyVector a

-- | O(n) Append an element to a Vector
--   
--   
--   >>> snocV (V.fromList [1,2]) 3
--   [1,2,3]
--   
snocV :: Vector a -> a -> NonEmptyVector a

-- | O(m+n) Concatenate two non-empty vectors
--   
--   
--   >>> (unsafeFromList [1..3]) ++ (unsafeFromList [4..6])
--   [1,2,3,4,5,6]
--   
(++) :: NonEmptyVector a -> NonEmptyVector a -> NonEmptyVector a

-- | O(n) Concatenate all non-empty vectors in the list
--   
--   If list is empty, Nothing is returned, otherwise Just
--   containing the concatenated non-empty vectors
--   
--   
--   >>> concat [(unsafeFromList [1..3]), (unsafeFromList [4..6])]
--   Just [1,2,3,4,5,6]
--   
concat :: [NonEmptyVector a] -> Maybe (NonEmptyVector a)

-- | O(n) Concatenate all non-empty vectors in a non-empty list.
--   
--   
--   >>> concat1 ((unsafeFromList [1..3]) :| [(unsafeFromList [4..6])])
--   [1,2,3,4,5,6]
--   
concat1 :: NonEmpty (NonEmptyVector a) -> NonEmptyVector a

-- | O(n) Yield the argument but force it not to retain any extra
--   memory, possibly by copying it.
force :: NonEmptyVector a -> NonEmptyVector a

-- | O(n) Convert a non-empty vector to a non-empty list.
--   
--   
--   >>> toNonEmpty (unsafeFromList [1..3])
--   1 :| [2,3]
--   
toNonEmpty :: NonEmptyVector a -> NonEmpty a

-- | O(n) Convert from a non-empty list to a non-empty vector.
--   
--   
--   >>> fromNonEmpty (1 :| [2,3])
--   [1,2,3]
--   
fromNonEmpty :: NonEmpty a -> NonEmptyVector a

-- | O(n) Convert from the first n-elements of a non-empty list to a
--   non-empty vector.
--   
--   Returns Nothing if indices are <= 0, otherwise Just
--   containing the non-empty vector.
--   
--   
--   >>> fromNonEmptyN 3 (1 :| [2..5])
--   Just [1,2,3]
--   
--   
--   
--   >>> fromNonEmptyN 0 (1 :| [2..5])
--   Nothing
--   
fromNonEmptyN :: Int -> NonEmpty a -> Maybe (NonEmptyVector a)

-- | O(n) Convert from the first n-elements of a non-empty list to a
--   non-empty vector. This is a safe version of fromNonEmptyN which
--   takes max n 1 of the first n-elements of the non-empty list.
--   
--   
--   >>> fromNonEmptyN1 3 (1 :| [2..5])
--   [1,2,3]
--   
--   
--   
--   >>> fromNonEmptyN1 0 (1 :| [2..5])
--   [1]
--   
fromNonEmptyN1 :: Int -> NonEmpty a -> NonEmptyVector a

-- | O(n) Convert from a list to a non-empty vector.
--   
--   Warning: the onus is on the user to ensure that their vector is
--   not empty, otherwise all bets are off!
--   
--   
--   >>> unsafeFromList [1..3]
--   [1,2,3]
--   
unsafeFromList :: [a] -> NonEmptyVector a

-- | O(1) Convert from a non-empty vector to a vector.
--   
--   
--   >>> let nev :: NonEmptyVector Int = unsafeFromList [1..3] in toVector nev
--   [1,2,3]
--   
toVector :: NonEmptyVector a -> Vector a

-- | O(1) Convert from a vector to a non-empty vector.
--   
--   If the vector is empty, then Nothing is returned, otherwise
--   Just containing the non-empty vector.
--   
--   
--   >>> fromVector $ V.fromList [1..3]
--   Just [1,2,3]
--   
--   
--   
--   >>> fromVector $ V.fromList []
--   Nothing
--   
fromVector :: Vector a -> Maybe (NonEmptyVector a)

-- | O(1) Convert from a vector to a non-empty vector without
--   checking bounds.
--   
--   Warning: the onus is on the user to ensure that their vector is
--   not empty, otherwise all bets are off!
--   
--   
--   >>> unsafeFromVector $ V.fromList [1..3]
--   [1,2,3]
--   
unsafeFromVector :: Vector a -> NonEmptyVector a

-- | O(n) Convert from a non-empty vector to a list.
--   
--   
--   >>> let nev :: NonEmptyVector Int = unsafeFromList [1..3] in toList nev
--   [1,2,3]
--   
toList :: NonEmptyVector a -> [a]

-- | O(n) Convert from a list to a non-empty vector.
--   
--   
--   >>> fromList [1..3]
--   Just [1,2,3]
--   
--   
--   
--   >>> fromList []
--   Nothing
--   
fromList :: [a] -> Maybe (NonEmptyVector a)

-- | O(n) Convert the first n elements of a list to a non-empty
--   vector.
--   
--   If the list is empty or <= 0 elements are chosen, Nothing is
--   returned, otherwise Just containing the non-empty vector
--   
--   
--   >>> fromListN 3 [1..5]
--   Just [1,2,3]
--   
--   
--   
--   >>> fromListN 3 []
--   Nothing
--   
--   
--   
--   >>> fromListN 0 [1..5]
--   Nothing
--   
fromListN :: Int -> [a] -> Maybe (NonEmptyVector a)

-- | O(m+n) For each pair (i,a) from the list, replace the non-empty
--   vector element at position i by a.
--   
--   
--   >>> unsafeFromList [1..3] // [(2,4)]
--   [1,2,4]
--   
--   
--   
--   >>> unsafeFromList [1..3] // []
--   [1,2,3]
--   
(//) :: NonEmptyVector a -> [(Int, a)] -> NonEmptyVector a

-- | O(m+n) For each pair (i,a) from the vector of index/value pairs,
--   replace the vector element at position i by a.
--   
--   
--   >>> unsafeFromList [1..3] `update` V.fromList [(2,4)]
--   [1,2,4]
--   
--   
--   
--   >>> unsafeFromList [1..3] `update` V.empty
--   [1,2,3]
--   
update :: NonEmptyVector a -> Vector (Int, a) -> NonEmptyVector a

-- | O(m+min(n1,n2)) For each index i from the index vector and the
--   corresponding value a from the value vector, replace the element of
--   the initial vector at position i by a.
--   
--   
--   >>> update_ (unsafeFromList [1..3]) (V.fromList [2]) (V.fromList [4])
--   [1,2,4]
--   
--   
--   
--   >>> update_ (unsafeFromList [1..3]) V.empty V.empty
--   [1,2,3]
--   
update_ :: NonEmptyVector a -> Vector Int -> Vector a -> NonEmptyVector a

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

-- | Same as update but without bounds checking.
unsafeUpdate :: NonEmptyVector a -> Vector (Int, a) -> NonEmptyVector a

-- | Same as update_ but without bounds checking.
unsafeUpdate_ :: NonEmptyVector a -> Vector Int -> Vector a -> NonEmptyVector a

-- | O(m+n) For each pair (i,b) from the non-empty list,
--   replace the non-empty vector element a at position i
--   by f a b.
--   
--   
--   >>> accum (+) (unsafeFromList [1..3]) [(2,10)]
--   [1,2,13]
--   
--   
--   
--   >>> accum (+) (unsafeFromList [1..3]) []
--   [1,2,3]
--   
accum :: (a -> b -> a) -> NonEmptyVector a -> [(Int, b)] -> NonEmptyVector a

-- | O(m+n) For each pair (i,b) from the vector of pairs,
--   replace the non-empty vector element a at position i
--   by f a b.
--   
--   
--   >>> accumulate (+) (unsafeFromList [1..3]) (V.fromList [(2,10)])
--   [1,2,13]
--   
--   
--   
--   >>> accumulate (+) (unsafeFromList [1..3]) V.empty
--   [1,2,3]
--   
accumulate :: (a -> b -> a) -> NonEmptyVector a -> Vector (Int, b) -> NonEmptyVector a

-- | O(m+min(n1,n2)) For each index i from the index vector
--   and the corresponding value b from the the value vector,
--   replace the element of the initial non-empty vector at position
--   i by f a b.
--   
--   
--   >>> accumulate_ (+) (unsafeFromList [1..3]) (V.fromList [2]) (V.fromList [10])
--   [1,2,13]
--   
--   
--   
--   >>> accumulate_ (+) (unsafeFromList [1..3]) V.empty V.empty
--   [1,2,3]
--   
accumulate_ :: (a -> b -> a) -> NonEmptyVector a -> Vector Int -> Vector b -> NonEmptyVector a

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

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

-- | Same as accumulate_ but without bounds checking.
unsafeAccumulate_ :: (a -> b -> a) -> NonEmptyVector a -> Vector Int -> Vector b -> NonEmptyVector a

-- | O(n) Reverse a non-empty vector
--   
--   
--   >>> reverse $ unsafeFromList [1..3]
--   [3,2,1]
--   
reverse :: NonEmptyVector a -> NonEmptyVector a

-- | O(n) Yield the non-empty vector obtained by replacing each
--   element i of the non-empty index vector by
--   xs!i. This is equivalent to map
--   (xs!) is but is often much more efficient.
--   
--   
--   >>> backpermute (unsafeFromList [1..3]) (unsafeFromList [2,0])
--   [3,1]
--   
backpermute :: NonEmptyVector a -> NonEmptyVector Int -> NonEmptyVector a

-- | Same as backpermute but without bounds checking.
unsafeBackpermute :: NonEmptyVector a -> NonEmptyVector Int -> NonEmptyVector a

-- | Apply a destructive operation to a non-empty vector. The operation
--   will be performed in place if it is safe to do so and will modify a
--   copy of the non-empty vector otherwise.
modify :: (forall s. () => MVector s a -> ST s ()) -> NonEmptyVector a -> NonEmptyVector a

-- | O(n) Pair each element in a vector with its index.
--   
--   
--   >>> indexed $ unsafeFromList ["a","b","c"]
--   [(0,"a"),(1,"b"),(2,"c")]
--   
indexed :: NonEmptyVector a -> NonEmptyVector (Int, a)

-- | O(n) Map a function over a non-empty vector.
--   
--   
--   >>> map (+1) $ unsafeFromList [1..3]
--   [2,3,4]
--   
map :: (a -> b) -> NonEmptyVector a -> NonEmptyVector b

-- | O(n) Apply a function to every element of a non-empty vector
--   and its index.
--   
--   
--   >>> imap (\i a -> if i == 2 then a+1 else a+0) $ unsafeFromList [1..3]
--   [1,2,4]
--   
imap :: (Int -> a -> b) -> NonEmptyVector a -> NonEmptyVector b

-- | Map a function over a vector and concatenate the results.
--   
--   
--   >>> concatMap (\a -> unsafeFromList [a,a]) (unsafeFromList [1,2,3])
--   [1,1,2,2,3,3]
--   
concatMap :: (a -> NonEmptyVector b) -> NonEmptyVector a -> NonEmptyVector b

-- | O(n) Apply the monadic action to all elements of the non-empty
--   vector, yielding non-empty vector of results.
--   
--   
--   >>> mapM Just (unsafeFromList [1..3])
--   Just [1,2,3]
--   
--   
--   
--   >>> mapM (const Nothing) (unsafeFromList [1..3])
--   Nothing
--   
mapM :: Monad m => (a -> m b) -> NonEmptyVector a -> m (NonEmptyVector b)

-- | O(n) Apply the monadic action to every element of a non-empty
--   vector and its index, yielding a non-empty vector of results.
--   
--   
--   >>> imapM (\i a -> if i == 1 then Just a else Just 0) (unsafeFromList [1..3])
--   Just [0,2,0]
--   
--   
--   
--   >>> imapM (\_ _ -> Nothing) (unsafeFromList [1..3])
--   Nothing
--   
imapM :: Monad m => (Int -> a -> m b) -> NonEmptyVector a -> m (NonEmptyVector b)

-- | O(n) Apply the monadic action to all elements of a non-empty
--   vector and ignore the results.
--   
--   
--   >>> mapM_ (const $ Just ()) (unsafeFromList [1..3])
--   Just ()
--   
--   
--   
--   >>> mapM_ (const Nothing) (unsafeFromList [1..3])
--   Nothing
--   
mapM_ :: Monad m => (a -> m b) -> NonEmptyVector a -> m ()

-- | O(n) Apply the monadic action to every element of a non-emptpy
--   vector and its index, ignoring the results
--   
--   
--   >>> imapM_ (\i a -> if i == 1 then P.print a else P.putStrLn "0") (unsafeFromList [1..3])
--   0
--   2
--   0
--   
--   
--   
--   >>> imapM_ (\_ _ -> Nothing) (unsafeFromList [1..3])
--   Nothing
--   
imapM_ :: Monad m => (Int -> a -> m b) -> NonEmptyVector a -> m ()

-- | O(n) Apply the monadic action to all elements of the non-empty
--   vector, yielding a non0empty vector of results.
--   
--   Equivalent to flip mapM.
forM :: Monad m => NonEmptyVector a -> (a -> m b) -> m (NonEmptyVector b)

-- | O(n) Apply the monadic action to all elements of a non-empty
--   vector and ignore the results.
--   
--   Equivalent to flip mapM_.
forM_ :: Monad m => NonEmptyVector a -> (a -> m b) -> m ()

-- | O(min(m,n)) Zip two non-empty vectors with the given function.
--   
--   
--   >>> zipWith (+) (unsafeFromList [1..3]) (unsafeFromList [1..3])
--   [2,4,6]
--   
zipWith :: (a -> b -> c) -> NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c

-- | Zip three non-empty vectors with the given function.
zipWith3 :: (a -> b -> c -> d) -> NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d

-- | Zip four non-empty vectors with the given function.
zipWith4 :: (a -> b -> c -> d -> e) -> NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector e

-- | Zip five non-empty vectors with the given function.
zipWith5 :: (a -> b -> c -> d -> e -> f) -> NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector e -> NonEmptyVector f

-- | Zip six non-empty vectors with the given function.
zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector e -> NonEmptyVector f -> NonEmptyVector g

-- | O(min(m,n)) Zip two non-empty vectors with a function that also
--   takes the elements' indices.
izipWith :: (Int -> a -> b -> c) -> NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c

-- | Zip three non-empty vectors and their indices with the given function.
izipWith3 :: (Int -> a -> b -> c -> d) -> NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d

-- | Zip four non-empty vectors and their indices with the given function.
izipWith4 :: (Int -> a -> b -> c -> d -> e) -> NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector e

-- | Zip five non-empty vectors and their indices with the given function.
izipWith5 :: (Int -> a -> b -> c -> d -> e -> f) -> NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector e -> NonEmptyVector f

-- | Zip six non-empty vectors and their indices with the given function.
izipWith6 :: (Int -> a -> b -> c -> d -> e -> f -> g) -> NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector e -> NonEmptyVector f -> NonEmptyVector g

-- | O(min(n,m)) Elementwise pairing of non-empty vector elements.
--   This is a special case of zipWith where the function argument
--   is (,)
zip :: NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector (a, b)

-- | Zip together three non-empty vectors.
zip3 :: NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector (a, b, c)

-- | Zip together four non-empty vectors.
zip4 :: NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector (a, b, c, d)

-- | Zip together five non-empty vectors.
zip5 :: NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector e -> NonEmptyVector (a, b, c, d, e)

-- | Zip together six non-empty vectors.
zip6 :: NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector e -> NonEmptyVector f -> NonEmptyVector (a, b, c, d, e, f)

-- | O(min(m,n)) Zip the two non-empty vectors with the monadic
--   action and yield a non-empty vector of results.
zipWithM :: Monad m => (a -> b -> m c) -> NonEmptyVector a -> NonEmptyVector b -> m (NonEmptyVector c)

-- | O(min(m,n)) Zip the two non-empty vectors with the monadic
--   action and ignore the results.
zipWithM_ :: Monad m => (a -> b -> m c) -> NonEmptyVector a -> NonEmptyVector b -> m ()

-- | O(min(m,n)) Zip the two non-empty vectors with a monadic action
--   that also takes the element index and yield a vector of results.
izipWithM :: Monad m => (Int -> a -> b -> m c) -> NonEmptyVector a -> NonEmptyVector b -> m (NonEmptyVector c)

-- | O(min(m,n)) Zip the two non-empty vectors with a monadic action
--   that also takes the element index and ignore the results.
izipWithM_ :: Monad m => (Int -> a -> b -> m c) -> NonEmptyVector a -> NonEmptyVector b -> m ()

-- | O(min(m,n)) Unzip a non-empty vector of pairs.
unzip :: NonEmptyVector (a, b) -> (NonEmptyVector a, NonEmptyVector b)

-- | Unzip a non-empty vector of triples.
unzip3 :: NonEmptyVector (a, b, c) -> (NonEmptyVector a, NonEmptyVector b, NonEmptyVector c)

-- | Unzip a non-empty vector of quadruples.
unzip4 :: NonEmptyVector (a, b, c, d) -> (NonEmptyVector a, NonEmptyVector b, NonEmptyVector c, NonEmptyVector d)

-- | Unzip a non-empty vector of quintuples.
unzip5 :: NonEmptyVector (a, b, c, d, e) -> (NonEmptyVector a, NonEmptyVector b, NonEmptyVector c, NonEmptyVector d, NonEmptyVector e)

-- | Unzip a non-empty vector of sextuples.
unzip6 :: NonEmptyVector (a, b, c, d, e, f) -> (NonEmptyVector a, NonEmptyVector b, NonEmptyVector c, NonEmptyVector d, NonEmptyVector e, NonEmptyVector f)

-- | O(n) Drop repeated adjacent elements.
--   
--   
--   >>> uniq $ unsafeFromList [1,1,2,2,3,3,1]
--   [1,2,3,1]
--   
uniq :: Eq a => NonEmptyVector a -> NonEmptyVector a

-- | O(n) Drop elements when predicate returns Nothing
--   
--   If no elements satisfy the predicate, the resulting vector may be
--   empty.
--   
--   
--   >>> mapMaybe (\a -> if a == 2 then Nothing else Just a) (unsafeFromList [1..3])
--   [1,3]
--   
mapMaybe :: (a -> Maybe b) -> NonEmptyVector a -> Vector b

-- | O(n) Drop elements when predicate, applied to index and value,
--   returns Nothing
--   
--   If no elements satisfy the predicate, the resulting vector may be
--   empty.
--   
--   
--   >>> imapMaybe (\i a -> if a == 2 || i == 2 then Nothing else Just a) (unsafeFromList [1..3])
--   [1]
--   
imapMaybe :: (Int -> a -> Maybe b) -> NonEmptyVector a -> Vector b

-- | O(n) Drop elements that do not satisfy the predicate.
--   
--   If no elements satisfy the predicate, the resulting vector may be
--   empty.
--   
--   
--   >>> filter (\a -> if a == 2 then False else True) (unsafeFromList [1..3])
--   [1,3]
--   
--   
--   
--   >>> filter (const False) (unsafeFromList [1..3])
--   []
--   
filter :: (a -> Bool) -> NonEmptyVector a -> Vector a

-- | O(n) Drop elements that do not satisfy the predicate which is
--   applied to values and their indices.
--   
--   If no elements satisfy the predicate, the resulting vector may be
--   empty.
--   
--   
--   >>> ifilter (\i a -> if a == 2 || i == 0 then False else True) (unsafeFromList [1..3])
--   [3]
--   
--   
--   
--   >>> ifilter (\_ _ -> False) (unsafeFromList [1..3])
--   []
--   
ifilter :: (Int -> a -> Bool) -> NonEmptyVector a -> Vector a

-- | O(n) Drop elements that do not satisfy the monadic predicate.
--   
--   If no elements satisfy the predicate, the resulting vector may be
--   empty.
--   
--   
--   >>> filterM (\a -> if a == 2 then Just False else Just True) (unsafeFromList [1..3])
--   Just [1,3]
--   
--   
--   
--   >>> filterM (\a -> if a == 2 then Nothing else Just True) (unsafeFromList [1..3])
--   Nothing
--   
--   
--   
--   >>> filterM (const $ Just False) (unsafeFromList [1..3])
--   Just []
--   
filterM :: Monad m => (a -> m Bool) -> NonEmptyVector a -> m (Vector a)

-- | O(n) Drop elements that do not satisfy the monadic predicate
--   that is a function of index and value.
--   
--   If no elements satisfy the predicate, the resulting vector may be
--   empty.
--   
--   TODO: this should be a more efficient function in vector.
--   
--   
--   >>> ifilterM (\i a -> if a == 2 || i == 0 then Just False else Just True) (unsafeFromList [1..3])
--   Just [3]
--   
--   
--   
--   >>> ifilterM (\i a -> if a == 2 || i == 0 then Nothing else Just True) (unsafeFromList [1..3])
--   Nothing
--   
--   
--   
--   >>> ifilterM (\_ _ -> Just False) (unsafeFromList [1..3])
--   Just []
--   
ifilterM :: Monad m => (Int -> a -> m Bool) -> NonEmptyVector a -> m (Vector a)

-- | O(n) Yield the longest prefix of elements satisfying the
--   predicate without copying.
--   
--   If no elements satisfy the predicate, the resulting vector may be
--   empty.
--   
--   
--   >>> takeWhile (/= 3) (unsafeFromList [1..3])
--   [1,2]
--   
takeWhile :: (a -> Bool) -> NonEmptyVector a -> Vector a

-- | O(n) Drop the longest prefix of elements that satisfy the
--   predicate without copying.
--   
--   If all elements satisfy the predicate, the resulting vector may be
--   empty.
--   
--   
--   >>> dropWhile (/= 3) (unsafeFromList [1..3])
--   [3]
--   
dropWhile :: (a -> Bool) -> NonEmptyVector a -> Vector a

-- | O(n) Split the non-empty vector in two parts, the first one
--   containing those elements that satisfy the predicate and the second
--   one those that don't. The relative order of the elements is preserved
--   at the cost of a sometimes reduced performance compared to
--   unstablePartition.
--   
--   If all or no elements satisfy the predicate, one of the resulting
--   vectors may be empty.
--   
--   
--   >>> partition (< 3) (unsafeFromList [1..5])
--   ([1,2],[3,4,5])
--   
partition :: (a -> Bool) -> NonEmptyVector a -> (Vector a, Vector a)

-- | O(n) Split the non-empty vector in two parts, the first one
--   containing the Left elements and the second containing the Right
--   elements. The relative order of the elements is preserved.
--   
--   If all elements produce a Left (or Right), one of the resulting
--   vectors may be empty.
--   
--   
--   >>> partitionWith (\a -> if a < 3 then Left a else Right (P.show a)) (unsafeFromList [1..5])
--   ([1,2],["3","4","5"])
--   
partitionWith :: (a -> Either b c) -> NonEmptyVector a -> (Vector b, Vector c)

-- | O(n) Split the non-empty vector in two parts, the first one
--   containing those elements that satisfy the predicate and the second
--   one those that don't. The order of the elements is not preserved but
--   the operation is often faster than partition.
--   
--   If all or no elements satisfy the predicate, one of the resulting
--   vectors may be empty.
unstablePartition :: (a -> Bool) -> NonEmptyVector a -> (Vector a, Vector a)

-- | O(n) Split the non-empty vector into the longest prefix of
--   elements that satisfy the predicate and the rest without copying.
--   
--   If all or no elements satisfy the predicate, one of the resulting
--   vectors may be empty.
--   
--   
--   >>> span (== 1) (unsafeFromList [1,1,2,3,1])
--   ([1,1],[2,3,1])
--   
span :: (a -> Bool) -> NonEmptyVector a -> (Vector a, Vector a)

-- | O(n) Split the vector into the longest prefix of elements that
--   do not satisfy the predicate and the rest without copying.
--   
--   If all or no elements satisfy the predicate, one of the resulting
--   vectors may be empty.
--   
--   
--   >>> break (== 2) (unsafeFromList [1,1,2,3,1])
--   ([1,1],[2,3,1])
--   
break :: (a -> Bool) -> NonEmptyVector a -> (Vector a, Vector a)

-- | O(n) Check if the non-empty vector contains an element
--   
--   
--   >>> elem 1 $ unsafeFromList [1..3]
--   True
--   
--   >>> elem 4 $ unsafeFromList [1..3]
--   False
--   
elem :: Eq a => a -> NonEmptyVector a -> Bool

-- | O(n) Check if the non-empty vector does not contain an element
--   (inverse of elem)
--   
--   
--   >>> notElem 1 $ unsafeFromList [1..3]
--   False
--   
--   
--   
--   >>> notElem 4 $ unsafeFromList [1..3]
--   True
--   
notElem :: Eq a => a -> NonEmptyVector a -> Bool

-- | O(n) Yield Just the first element matching the predicate
--   or Nothing if no such element exists.
--   
--   
--   >>> find (< 2) $ unsafeFromList [1..3]
--   Just 1
--   
--   
--   
--   >>> find (< 0) $ unsafeFromList [1..3]
--   Nothing
--   
find :: (a -> Bool) -> NonEmptyVector a -> Maybe a

-- | O(n) Yield Just the index of the first element matching
--   the predicate or Nothing if no such element exists.
--   
--   
--   >>> findIndex (< 2) $ unsafeFromList [1..3]
--   Just 0
--   
--   
--   
--   >>> findIndex (< 0) $ unsafeFromList [1..3]
--   Nothing
--   
findIndex :: (a -> Bool) -> NonEmptyVector a -> Maybe Int

-- | O(n) Yield the indices of elements satisfying the predicate in
--   ascending order.
--   
--   
--   >>> findIndices (< 3) $ unsafeFromList [1..3]
--   [0,1]
--   
--   
--   
--   >>> findIndices (< 0) $ unsafeFromList [1..3]
--   []
--   
findIndices :: (a -> Bool) -> NonEmptyVector a -> Vector Int

-- | O(n) Yield Just the index of the first occurence of the
--   given element or Nothing if the non-empty vector does not
--   contain the element. This is a specialised version of
--   findIndex.
--   
--   
--   >>> elemIndex 1 $ unsafeFromList [1..3]
--   Just 0
--   
--   
--   
--   >>> elemIndex 0 $ unsafeFromList [1..3]
--   Nothing
--   
elemIndex :: Eq a => a -> NonEmptyVector a -> Maybe Int

-- | O(n) Yield the indices of all occurences of the given element
--   in ascending order. This is a specialised version of
--   findIndices.
--   
--   
--   >>> elemIndices 1 $ unsafeFromList [1,2,3,1]
--   [0,3]
--   
--   
--   
--   >>> elemIndices 0 $ unsafeFromList [1..3]
--   []
--   
elemIndices :: Eq a => a -> NonEmptyVector a -> Vector Int

-- | O(n) Left monoidal fold
foldl :: (a -> b -> a) -> a -> NonEmptyVector b -> a

-- | O(n) Left semigroupal fold
foldl1 :: (a -> a -> a) -> NonEmptyVector a -> a

-- | O(n) Strict Left monoidal fold
foldl' :: (a -> b -> a) -> a -> NonEmptyVector b -> a

-- | O(n) Strict Left semigroupal fold
foldl1' :: (a -> a -> a) -> NonEmptyVector a -> a

-- | O(n) Right monoidal fold
foldr :: (a -> b -> b) -> b -> NonEmptyVector a -> b

-- | O(n) Right semigroupal fold
foldr1 :: (a -> a -> a) -> NonEmptyVector a -> a

-- | O(n) Strict right monoidal fold
foldr' :: (a -> b -> b) -> b -> NonEmptyVector a -> b

-- | O(n) Strict right semigroupal fold
foldr1' :: (a -> a -> a) -> NonEmptyVector a -> a

-- | O(n) Left monoidal fold with function applied to each element
--   and its index
ifoldl :: (a -> Int -> b -> a) -> a -> NonEmptyVector b -> a

-- | O(n) Strict left monoidal fold with function applied to each
--   element and its index
ifoldl' :: (a -> Int -> b -> a) -> a -> NonEmptyVector b -> a

-- | O(n) Right monoidal fold with function applied to each element
--   and its index
ifoldr :: (Int -> a -> b -> b) -> b -> NonEmptyVector a -> b

-- | O(n) strict right monoidal fold with function applied to each
--   element and its index
ifoldr' :: (Int -> a -> b -> b) -> b -> NonEmptyVector a -> b

-- | O(n) Check if all elements satisfy the predicate.
all :: (a -> Bool) -> NonEmptyVector a -> Bool

-- | O(n) Check if any element satisfies the predicate.
any :: (a -> Bool) -> NonEmptyVector a -> Bool

-- | O(n) Check if all elements are True.
and :: NonEmptyVector Bool -> Bool

-- | O(n) Check if any element is True
or :: NonEmptyVector Bool -> Bool

-- | O(n) Compute the sum of the elements
sum :: Num a => NonEmptyVector a -> a

-- | O(n) Compute the produce of the elements
product :: Num a => NonEmptyVector a -> a

-- | O(n) Yield the maximum element of the non-empty vector.
maximum :: Ord a => NonEmptyVector a -> a

-- | O(n) Yield the maximum element of a non-empty vector according
--   to the given comparison function.
maximumBy :: (a -> a -> Ordering) -> NonEmptyVector a -> a

-- | O(n) Yield the minimum element of the non-empty vector.
minimum :: Ord a => NonEmptyVector a -> a

-- | O(n) Yield the minimum element of the non-empty vector
--   according to the given comparison function.
minimumBy :: (a -> a -> Ordering) -> NonEmptyVector a -> a

-- | O(n) Yield the index of the maximum element of the non-empty
--   vector.
maxIndex :: Ord a => NonEmptyVector a -> Int

-- | O(n) Yield the index of the maximum element of the vector
--   according to the given comparison function.
maxIndexBy :: (a -> a -> Ordering) -> NonEmptyVector a -> Int

-- | O(n) Yield the index of the minimum element of the non-empty
--   vector.
minIndex :: Ord a => NonEmptyVector a -> Int

-- | O(n) Yield the index of the minimum element of the vector
--   according to the given comparison function.
minIndexBy :: (a -> a -> Ordering) -> NonEmptyVector a -> Int

-- | O(n) Monadic fold
foldM :: Monad m => (a -> b -> m a) -> a -> NonEmptyVector b -> m a

-- | O(n) Strict monadic fold
foldM' :: Monad m => (a -> b -> m a) -> a -> NonEmptyVector b -> m a

-- | O(n) Monadic semigroupal fold
fold1M :: Monad m => (a -> a -> m a) -> NonEmptyVector a -> m a

-- | O(n) Strict monadic semigroupal fold
fold1M' :: Monad m => (a -> a -> m a) -> NonEmptyVector a -> m a

-- | O(n) Monadic fold that discards the result
foldM_ :: Monad m => (a -> b -> m a) -> a -> NonEmptyVector b -> m ()

-- | O(n) Strict monadic fold that discards the result
foldM'_ :: Monad m => (a -> b -> m a) -> a -> NonEmptyVector b -> m ()

-- | O(n) Monadic semigroupal fold that discards the result
fold1M_ :: Monad m => (a -> a -> m a) -> NonEmptyVector a -> m ()

-- | O(n) Strict monadic semigroupal fold that discards the result
fold1M'_ :: Monad m => (a -> a -> m a) -> NonEmptyVector a -> m ()

-- | O(n) Monadic fold (action applied to each element and its
--   index)
ifoldM :: Monad m => (a -> Int -> b -> m a) -> a -> NonEmptyVector b -> m a

-- | O(n) Strict monadic fold (action applied to each element and
--   its index)
ifoldM' :: Monad m => (a -> Int -> b -> m a) -> a -> NonEmptyVector b -> m a

-- | O(n) Monadic fold that discards the result (action applied to
--   each element and its index)
ifoldM_ :: Monad m => (a -> Int -> b -> m a) -> a -> NonEmptyVector b -> m ()

-- | O(n) Strict monadic fold that discards the result (action
--   applied to each element and its index)
ifoldM'_ :: Monad m => (a -> Int -> b -> m a) -> a -> NonEmptyVector b -> m ()

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

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

-- | O(n) Prescan
prescanl :: (a -> b -> a) -> a -> NonEmptyVector b -> NonEmptyVector a

-- | O(n) Prescan with strict accumulator
prescanl' :: (a -> b -> a) -> a -> NonEmptyVector b -> NonEmptyVector a

-- | O(n) Scan
postscanl :: (a -> b -> a) -> a -> NonEmptyVector b -> NonEmptyVector a

-- | O(n) Scan with a strict accumulator
postscanl' :: (a -> b -> a) -> a -> NonEmptyVector b -> NonEmptyVector a

-- | O(n) Haskell-style scan
scanl :: (a -> b -> a) -> a -> NonEmptyVector b -> NonEmptyVector a

-- | O(n) Haskell-style scan with strict accumulator
scanl' :: (a -> b -> a) -> a -> NonEmptyVector b -> NonEmptyVector a

-- | O(n) Semigroupal left scan
scanl1 :: (a -> a -> a) -> NonEmptyVector a -> NonEmptyVector a

-- | O(n) Strict semigroupal scan
scanl1' :: (a -> a -> a) -> NonEmptyVector a -> NonEmptyVector a

-- | O(n) Scan over a vector with its index
iscanl :: (Int -> a -> b -> a) -> a -> NonEmptyVector b -> NonEmptyVector a

-- | O(n) Scan over a vector with its index with strict accumulator
iscanl' :: (Int -> a -> b -> a) -> a -> NonEmptyVector b -> NonEmptyVector a

-- | O(n) Right-to-left prescan
prescanr :: (a -> b -> b) -> b -> NonEmptyVector a -> NonEmptyVector b

-- | O(n) Right-to-left prescan with strict accumulator
prescanr' :: (a -> b -> b) -> b -> NonEmptyVector a -> NonEmptyVector b

-- | O(n) Right-to-left scan
postscanr :: (a -> b -> b) -> b -> NonEmptyVector a -> NonEmptyVector b

-- | O(n) Right-to-left scan with strict accumulator
postscanr' :: (a -> b -> b) -> b -> NonEmptyVector a -> NonEmptyVector b

-- | O(n) Right-to-left Haskell-style scan
scanr :: (a -> b -> b) -> b -> NonEmptyVector a -> NonEmptyVector b

-- | O(n) Right-to-left Haskell-style scan with strict accumulator
scanr' :: (a -> b -> b) -> b -> NonEmptyVector a -> NonEmptyVector b

-- | O(n) Right-to-left Haskell-style semigroupal scan
scanr1 :: (a -> a -> a) -> NonEmptyVector a -> NonEmptyVector a

-- | O(n) Right-to-left Haskell-style semigroupal scan with strict
--   accumulator
scanr1' :: (a -> a -> a) -> NonEmptyVector a -> NonEmptyVector a

-- | O(n) Right-to-left scan over a vector with its index
iscanr :: (Int -> a -> b -> b) -> b -> NonEmptyVector a -> NonEmptyVector b

-- | O(n) Right-to-left scan over a vector with its index and a
--   strict accumulator
iscanr' :: (Int -> a -> b -> b) -> b -> NonEmptyVector a -> NonEmptyVector b

-- | Non-empty mutable boxed vectors.
module Data.Vector.NonEmpty.Mutable

-- | NonEmptyMVector is a thin wrapper around MVector that
--   witnesses an API requiring non-empty construction, initialization, and
--   generation of non-empty vectors by design.
--   
--   A newtype wrapper was chosen so that no new pointer indirection is
--   introduced when working with MVectors, and all performance
--   characteristics inherited from the MVector API still apply.
data NonEmptyMVector s a

-- | NonEmptyMVector parametrized by PrimState
type NonEmptyIOVector = NonEmptyMVector RealWorld

-- | NonEmptyMVector parametrized by ST
type NonEmptySTVector s = NonEmptyMVector s

-- | Length of the mutable vector.
length :: NonEmptyMVector s a -> Int

-- | Yield a part of the mutable vector without copying.
slice :: Int -> Int -> NonEmptyMVector s a -> MVector s a

-- | Yield all but the last element without copying.
init :: NonEmptyMVector s a -> MVector s a

-- | Yield all but the first element without copying.
tail :: NonEmptyMVector s a -> MVector s a

-- | Yield at the first n elements without copying.
take :: Int -> NonEmptyMVector s a -> MVector s a

-- | Yield all but the first n elements without copying.
drop :: Int -> NonEmptyMVector s a -> MVector s a

-- | Yield the first n elements paired with the remainder without copying.
splitAt :: Int -> NonEmptyMVector s a -> (MVector s a, MVector s a)

-- | Yield a part of the mutable vector without copying it. No bounds
--   checks are performed.
unsafeSlice :: Int -> Int -> NonEmptyMVector s a -> MVector s a

-- | Yield the first n elements without copying. The vector must contain at
--   least n elements but this is not checked.
unsafeTake :: Int -> NonEmptyMVector s a -> MVector s a

-- | Yield all but the first n elements without copying. The vector must
--   contain at least n elements but this is not checked.
unsafeDrop :: Int -> NonEmptyMVector s a -> MVector s a

-- | Check whether two vectors overlap.
overlaps :: NonEmptyMVector s a -> NonEmptyMVector s a -> Bool

-- | Convert a mutable vector to a non-empty mutable vector
fromMVector :: MVector s a -> Maybe (NonEmptyMVector s a)

-- | Convert a non-empty mutable vector to a mutable vector
toMVector :: NonEmptyMVector s a -> MVector s a

-- | Convert a mutable vector to a non-empty mutable vector
--   
--   Warning: this function is unsafe and can result in empty
--   non-empty mutable vectors. If you call this function, the onus is on
--   you to make sure the mutable vector being converted is not empty.
unsafeFromMVector :: MVector s a -> NonEmptyMVector s a

-- | Create a mutable vector of the given length.
new :: PrimMonad m => Int -> m (Maybe (NonEmptyMVector (PrimState m) a))

-- | Create a mutable vector of the given length which is max n 1.
new1 :: PrimMonad m => Int -> m (NonEmptyMVector (PrimState m) a)

-- | Create a mutable vector of the given length. The memory is not
--   initialized.
unsafeNew :: PrimMonad m => Int -> m (Maybe (NonEmptyMVector (PrimState m) a))

-- | Create a mutable vector of the given length (0 if the length is
--   negative) and fill it with an initial value.
replicate :: PrimMonad m => Int -> a -> m (Maybe (NonEmptyMVector (PrimState m) a))

-- | Create a mutable vector of the length max n 1 for a given
--   length, and fill it with an initial value.
replicate1 :: PrimMonad m => Int -> a -> m (NonEmptyMVector (PrimState m) a)

-- | Create a mutable vector of the given length (0 if the length is
--   negative) and fill it with values produced by repeatedly executing the
--   monadic action.
replicateM :: PrimMonad m => Int -> m a -> m (Maybe (NonEmptyMVector (PrimState m) a))

-- | Create a mutable vector of the length max n 1 for a given
--   length, and fill it with values produced by repeatedly executing the
--   monadic action.
replicate1M :: PrimMonad m => Int -> m a -> m (Maybe (NonEmptyMVector (PrimState m) a))

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

-- | Grow a vector by the given number of elements. The number must be
--   positive.
grow :: PrimMonad m => NonEmptyMVector (PrimState m) a -> Int -> m (NonEmptyMVector (PrimState m) a)

-- | Grow a vector by the given number of elements. The number must be
--   positive but this is not checked.
unsafeGrow :: PrimMonad m => NonEmptyMVector (PrimState m) a -> Int -> m (NonEmptyMVector (PrimState m) a)

-- | Reset all elements of the vector to some undefined value, clearing all
--   references to external objects. This is usually a noop for unboxed
--   vectors.
clear :: PrimMonad m => NonEmptyMVector (PrimState m) a -> m ()

-- | Yield the element at the given position.
read :: PrimMonad m => NonEmptyMVector (PrimState m) a -> Int -> m a

-- | Replace the element at the given position.
write :: PrimMonad m => NonEmptyMVector (PrimState m) a -> Int -> a -> m ()

-- | Modify the element at the given position.
modify :: PrimMonad m => NonEmptyMVector (PrimState m) a -> (a -> a) -> Int -> m ()

-- | Swap the elements at the given positions.
swap :: PrimMonad m => NonEmptyMVector (PrimState m) a -> Int -> Int -> m ()

-- | Yield the element at the given position. No bounds checks are
--   performed.
unsafeRead :: PrimMonad m => NonEmptyMVector (PrimState m) a -> Int -> m a

-- | Replace the element at the given position. No bounds checks are
--   performed.
unsafeWrite :: PrimMonad m => NonEmptyMVector (PrimState m) a -> Int -> a -> m ()

-- | Modify the element at the given position. No bounds checks are
--   performed.
unsafeModify :: PrimMonad m => NonEmptyMVector (PrimState m) a -> (a -> a) -> Int -> m ()

-- | Swap the elements at the given positions. No bounds checks are
--   performed.
unsafeSwap :: PrimMonad m => NonEmptyMVector (PrimState m) a -> Int -> Int -> m ()

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

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

-- | Copy a vector. The two vectors must have the same length and may not
--   overlap.
copy :: PrimMonad m => NonEmptyMVector (PrimState m) a -> NonEmptyMVector (PrimState m) a -> m ()

-- | Move the contents of a vector. The two vectors must have the same
--   length.
--   
--   If the vectors do not overlap, then this is equivalent to copy.
--   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 => NonEmptyMVector (PrimState m) a -> NonEmptyMVector (PrimState m) a -> m ()

-- | Copy a vector. The two vectors must have the same length and may not
--   overlap. This is not checked.
unsafeCopy :: PrimMonad m => NonEmptyMVector (PrimState m) a -> NonEmptyMVector (PrimState m) a -> m ()

-- | Move the contents of a vector. The two vectors must have the same
--   length, but this is not checked.
--   
--   If the vectors do not overlap, then this is equivalent to
--   unsafeCopy. 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.
unsafeMove :: PrimMonad m => NonEmptyMVector (PrimState m) a -> NonEmptyMVector (PrimState m) a -> m ()
