    {-# LANGUAGE BangPatterns #-}
    {-# LANGUAGE CPP #-}
    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE RankNTypes #-}
    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE TypeApplications #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    -- |
    -- Module      : Data.Vector.Strict
    -- Copyright   : (c) Roman Leshchinskiy 2008-2010
    --                   Alexey Kuleshevich 2020-2022
    --                   Aleksey Khudyakov 2020-2022
    --                   Andrew Lelechenko 2020-2022
    -- License     : BSD-style
    --
    -- Maintainer  : Haskell Libraries Team <libraries@haskell.org>
    -- Stability   : experimental
    -- Portability : non-portable
    --
    -- Immutable strict boxed vectors (that is, polymorphic arrays capable
    -- of holding any Haskell value). Vectors created using API for
    -- immutable vector will have all elements evaluated to WHNF. Note
    -- it's possible to create vector containing bottoms using mutable API
    -- ('Data.Vector.Strict.Mutable.new' initialize vector with ⊥) fill
    -- but all subsequent writes will be evauated to WHNF.
    --
    -- For unboxed arrays, use "Data.Vector.Unboxed".
    module Data.Vector.Strict (
      -- * Boxed vectors
      Vector, MVector,

      -- * Accessors

      -- ** Length information
      length, null,

      -- ** Indexing
      (!), (!?), head, last,
      unsafeIndex, unsafeHead, unsafeLast,

      -- ** Monadic indexing
      indexM, headM, lastM,
      unsafeIndexM, unsafeHeadM, unsafeLastM,

      -- ** Extracting subvectors (slicing)
      slice, init, tail, take, drop, splitAt, uncons, unsnoc,
      unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,

      -- * Construction

      -- ** Initialisation
      empty, singleton, replicate, generate, iterateN,

      -- ** Monadic initialisation
      replicateM, generateM, iterateNM, create, createT,

      -- ** Unfolding
      unfoldr, unfoldrN, unfoldrExactN,
      unfoldrM, unfoldrNM, unfoldrExactNM,
      constructN, constructrN,

      -- ** Enumeration
      enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,

      -- ** Concatenation
      cons, snoc, (++), concat,

      -- ** Restricting memory usage
      force,

      -- * Modifying vectors

      -- ** Bulk updates
      (//), update, update_,
      unsafeUpd, unsafeUpdate, unsafeUpdate_,

      -- ** Accumulations
      accum, accumulate, accumulate_,
      unsafeAccum, unsafeAccumulate, unsafeAccumulate_,

      -- ** Permutations
      reverse, backpermute, unsafeBackpermute,

      -- ** Safe destructive updates
      modify,

      -- * Elementwise operations

      -- ** Indexing
      indexed,

      -- ** Mapping
      map, imap, concatMap,

      -- ** Monadic mapping
      mapM, imapM, mapM_, imapM_, forM, forM_,
      iforM, iforM_,

      -- ** Zipping
      zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
      izipWith, izipWith3, izipWith4, izipWith5, izipWith6,
      zip, zip3, zip4, zip5, zip6,

      -- ** Monadic zipping
      zipWithM, izipWithM, zipWithM_, izipWithM_,

      -- ** Unzipping
      unzip, unzip3, unzip4, unzip5, unzip6,

      -- * Working with predicates

      -- ** Filtering
      filter, ifilter, filterM, uniq,
      mapMaybe, imapMaybe,
      mapMaybeM, imapMaybeM,
      catMaybes,
      takeWhile, dropWhile,

      -- ** Partitioning
      partition, unstablePartition, partitionWith, span, break, spanR, breakR, groupBy, group,

      -- ** Searching
      elem, notElem, find, findIndex, findIndexR, findIndices, elemIndex, elemIndices,

      -- * Folding
      foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1',
      ifoldl, ifoldl', ifoldr, ifoldr',
      foldMap, foldMap',

      -- ** Specialised folds
      all, any, and, or,
      sum, product,
      maximum, maximumBy, maximumOn,
      minimum, minimumBy, minimumOn,
      minIndex, minIndexBy, maxIndex, maxIndexBy,

      -- ** Monadic folds
      foldM, ifoldM, foldM', ifoldM',
      fold1M, fold1M',foldM_, ifoldM_,
      foldM'_, ifoldM'_, fold1M_, fold1M'_,

      -- ** Monadic sequencing
      sequence, sequence_,

      -- * Scans
      prescanl, prescanl',
      postscanl, postscanl',
      scanl, scanl', scanl1, scanl1',
      iscanl, iscanl',
      prescanr, prescanr',
      postscanr, postscanr',
      scanr, scanr', scanr1, scanr1',
      iscanr, iscanr',

      -- ** Comparisons
      eqBy, cmpBy,

      -- * Conversions

      -- ** Lists
      toList, Data.Vector.Strict.fromList, Data.Vector.Strict.fromListN,
      -- ** Lazy vectors
      toLazy, fromLazy,
      -- ** Arrays
      toArray, fromArray, toArraySlice, unsafeFromArraySlice,

      -- ** Other vector types
      G.convert,

      -- ** Mutable vectors
      freeze, thaw, copy, unsafeFreeze, unsafeThaw, unsafeCopy
    ) where

    import Data.Coerce
    import Data.Vector.Strict.Mutable  ( MVector(..) )
    import Data.Primitive.Array
    import qualified Data.Vector.Fusion.Bundle as Bundle
    import qualified Data.Vector.Generic as G
    import qualified Data.Vector as V

    import Control.DeepSeq ( NFData(rnf)
    #if MIN_VERSION_deepseq(1,4,3)
                           , NFData1(liftRnf)
    #endif
                           )

    import Control.Monad ( MonadPlus(..), ap )
    #if !MIN_VERSION_base(4,13,0)
    import Control.Monad (fail)
    #endif
    import Control.Monad.ST ( ST, runST )
    import Control.Monad.Primitive
    import qualified Control.Monad.Fail as Fail
    import Control.Monad.Fix ( MonadFix (mfix) )
    import Control.Monad.Zip
    import Data.Function ( fix )

    import Prelude
      ( Eq(..), Ord(..), Num, Enum, Monoid, Functor, Monad, Show, Bool, Ordering(..), Int, Maybe, Either
      , return, showsPrec, fmap, otherwise, id, flip, const
      , (>>=), (+), (-), (.), ($), seq)

    import Data.Functor.Classes (Eq1 (..), Ord1 (..), Read1 (..), Show1 (..))
    import Data.Typeable  ( Typeable )
    import Data.Data      ( Data(..) )
    import Text.Read      ( Read(..), readListPrecDefault )
    import Data.Semigroup ( Semigroup(..) )

    import qualified Control.Applicative as Applicative
    import qualified Data.Foldable as Foldable
    import qualified Data.Traversable as Traversable

    import qualified GHC.Exts as Exts (IsList(..))

    -- | Strict boxed vectors, supporting efficient slicing.
    newtype Vector a = Vector (V.Vector a)
      deriving (Typeable, (forall m. Monoid m => Vector m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Vector a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Vector a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Vector a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Vector a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Vector a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Vector a -> b)
    -> (forall a. (a -> a -> a) -> Vector a -> a)
    -> (forall a. (a -> a -> a) -> Vector a -> a)
    -> (forall a. Vector a -> [a])
    -> (forall a. Vector a -> Bool)
    -> (forall a. Vector a -> Int)
    -> (forall a. Eq a => a -> Vector a -> Bool)
    -> (forall a. Ord a => Vector a -> a)
    -> (forall a. Ord a => Vector a -> a)
    -> (forall a. Num a => Vector a -> a)
    -> (forall a. Num a => Vector a -> a)
    -> Foldable Vector
    forall a. Eq a => a -> Vector a -> Bool
    forall a. Num a => Vector a -> a
    forall a. Ord a => Vector a -> a
    forall m. Monoid m => Vector m -> m
    forall a. Vector a -> Bool
    forall a. Vector a -> Int
    forall a. Vector a -> [a]
    forall a. (a -> a -> a) -> Vector a -> a
    forall m a. Monoid m => (a -> m) -> Vector a -> m
    forall b a. (b -> a -> b) -> b -> Vector a -> b
    forall a b. (a -> b -> b) -> b -> Vector a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Vector m -> m
    fold :: forall m. Monoid m => Vector m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Vector a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Vector a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Vector a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Vector a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Vector a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Vector a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Vector a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Vector a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Vector a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Vector a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Vector a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Vector a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Vector a -> a
    foldr1 :: forall a. (a -> a -> a) -> Vector a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Vector a -> a
    foldl1 :: forall a. (a -> a -> a) -> Vector a -> a
    $ctoList :: forall a. Vector a -> [a]
    toList :: forall a. Vector a -> [a]
    $cnull :: forall a. Vector a -> Bool
    null :: forall a. Vector a -> Bool
    $clength :: forall a. Vector a -> Int
    length :: forall a. Vector a -> Int
    $celem :: forall a. Eq a => a -> Vector a -> Bool
    elem :: forall a. Eq a => a -> Vector a -> Bool
    $cmaximum :: forall a. Ord a => Vector a -> a
    maximum :: forall a. Ord a => Vector a -> a
    $cminimum :: forall a. Ord a => Vector a -> a
    minimum :: forall a. Ord a => Vector a -> a
    $csum :: forall a. Num a => Vector a -> a
    sum :: forall a. Num a => Vector a -> a
    $cproduct :: forall a. Num a => Vector a -> a
    product :: forall a. Num a => Vector a -> a
    Foldable.Foldable, NonEmpty (Vector a) -> Vector a
    Vector a -> Vector a -> Vector a
    (Vector a -> Vector a -> Vector a)
    -> (NonEmpty (Vector a) -> Vector a)
    -> (forall b. Integral b => b -> Vector a -> Vector a)
    -> Semigroup (Vector a)
    forall b. Integral b => b -> Vector a -> Vector a
    forall a. NonEmpty (Vector a) -> Vector a
    forall a. Vector a -> Vector a -> Vector a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    forall a b. Integral b => b -> Vector a -> Vector a
    $c<> :: forall a. Vector a -> Vector a -> Vector a
    <> :: Vector a -> Vector a -> Vector a
    $csconcat :: forall a. NonEmpty (Vector a) -> Vector a
    sconcat :: NonEmpty (Vector a) -> Vector a
    $cstimes :: forall a b. Integral b => b -> Vector a -> Vector a
    stimes :: forall b. Integral b => b -> Vector a -> Vector a
    Semigroup, Semigroup (Vector a)
    Vector a
    Semigroup (Vector a) =>
    Vector a
    -> (Vector a -> Vector a -> Vector a)
    -> ([Vector a] -> Vector a)
    -> Monoid (Vector a)
    [Vector a] -> Vector a
    Vector a -> Vector a -> Vector a
    forall a. Semigroup (Vector a)
    forall a. Vector a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    forall a. [Vector a] -> Vector a
    forall a. Vector a -> Vector a -> Vector a
    $cmempty :: forall a. Vector a
    mempty :: Vector a
    $cmappend :: forall a. Vector a -> Vector a -> Vector a
    mappend :: Vector a -> Vector a -> Vector a
    $cmconcat :: forall a. [Vector a] -> Vector a
    mconcat :: [Vector a] -> Vector a
    Monoid)

    -- NOTE: [GND for strict vector]
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    --
    -- Strict boxed vectors (both mutable an immutable) are newtypes over
    -- lazy ones. This makes it possible to use GND to derive instances.
    -- However one must take care to preserve strictness since Vector
    -- instance for lazy vectors would be used.
    --
    -- In general it's OK to derive instances where vectors are passed as
    -- parameters (e.g. Eq, Ord) and not OK to derive ones where new
    -- vector is created (e.g. Read, Functor)

    liftRnfV :: (a -> ()) -> Vector a -> ()
    liftRnfV :: forall a. (a -> ()) -> Vector a -> ()
    liftRnfV a -> ()
    elemRnf = (() -> a -> ()) -> () -> Vector a -> ()
    forall b a. (b -> a -> b) -> b -> Vector a -> b
    foldl' (\()
    _ -> a -> ()
    elemRnf) ()

    instance NFData a => NFData (Vector a) where
      rnf :: Vector a -> ()
    rnf = (a -> ()) -> Vector a -> ()
    forall a. (a -> ()) -> Vector a -> ()
    liftRnfV a -> ()
    forall a. NFData a => a -> ()
    rnf
      {-# INLINEABLE rnf #-}

    #if MIN_VERSION_deepseq(1,4,3)
    -- | @since 0.13.2.0
    instance NFData1 Vector where
      liftRnf :: forall a. (a -> ()) -> Vector a -> ()
    liftRnf = (a -> ()) -> Vector a -> ()
    forall a. (a -> ()) -> Vector a -> ()
    liftRnfV
      {-# INLINEABLE liftRnf #-}
    #endif

    instance Show a => Show (Vector a) where
      showsPrec :: Int -> Vector a -> ShowS
    showsPrec = Int -> Vector a -> ShowS
    forall (v :: * -> *) a. (Vector v a, Show a) => Int -> v a -> ShowS
    G.showsPrec

    instance Read a => Read (Vector a) where
      readPrec :: ReadPrec (Vector a)
    readPrec = ReadPrec (Vector a)
    forall (v :: * -> *) a. (Vector v a, Read a) => ReadPrec (v a)
    G.readPrec
      readListPrec :: ReadPrec [Vector a]
    readListPrec = ReadPrec [Vector a]
    forall a. Read a => ReadPrec [a]
    readListPrecDefault

    instance Show1 Vector where
      liftShowsPrec :: forall a.
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Vector a -> ShowS
    liftShowsPrec = (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Vector a -> ShowS
    forall (v :: * -> *) a.
    Vector v a =>
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> v a -> ShowS
    G.liftShowsPrec

    instance Read1 Vector where
      liftReadsPrec :: forall a. (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Vector a)
    liftReadsPrec = (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Vector a)
    forall (v :: * -> *) a.
    Vector v a =>
    (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (v a)
    G.liftReadsPrec

    instance Exts.IsList (Vector a) where
      type Item (Vector a) = a
      fromList :: [Item (Vector a)] -> Vector a
    fromList = [a] -> Vector a
    [Item (Vector a)] -> Vector a
    forall a. [a] -> Vector a
    Data.Vector.Strict.fromList
      fromListN :: Int -> [Item (Vector a)] -> Vector a
    fromListN = Int -> [a] -> Vector a
    Int -> [Item (Vector a)] -> Vector a
    forall a. Int -> [a] -> Vector a
    Data.Vector.Strict.fromListN
      toList :: Vector a -> [Item (Vector a)]
    toList = Vector a -> [a]
    Vector a -> [Item (Vector a)]
    forall a. Vector a -> [a]
    toList

    instance Data a => Data (Vector a) where
      gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Vector a -> c (Vector a)
    gfoldl       = (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Vector a -> c (Vector a)
    forall (v :: * -> *) a (c :: * -> *).
    (Vector v a, Data a) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> v a -> c (v a)
    G.gfoldl
      toConstr :: Vector a -> Constr
    toConstr Vector a
    _   = String -> Constr
    G.mkVecConstr String
    "Data.Vector.Strict.Vector"
      gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Vector a)
    gunfold      = (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Vector a)
    forall (v :: * -> *) a (c :: * -> *).
    (Vector v a, Data a, HasCallStack) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (v a)
    G.gunfold
      dataTypeOf :: Vector a -> DataType
    dataTypeOf Vector a
    _ = String -> DataType
    G.mkVecType String
    "Data.Vector.Strict.Vector"
      dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Vector a))
    dataCast1    = (forall d. Data d => c (t d)) -> Maybe (c (Vector a))
    forall (v :: * -> *) a (t :: * -> *) (c :: * -> *).
    (Vector v a, Data a, Typeable v, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (v a))
    G.dataCast

    type instance G.Mutable Vector = MVector

    instance G.Vector Vector a where
      {-# INLINE basicUnsafeFreeze #-}
      basicUnsafeFreeze :: forall s. Mutable Vector s a -> ST s (Vector a)
    basicUnsafeFreeze = (MVector s a -> ST s (Vector a)) -> MVector s a -> ST s (Vector a)
    forall a b. Coercible a b => a -> b
    coerce (forall (v :: * -> *) a s. Vector v a => Mutable v s a -> ST s (v a)
    G.basicUnsafeFreeze @V.Vector @a)
      {-# INLINE basicUnsafeThaw #-}
      basicUnsafeThaw :: forall s. Vector a -> ST s (Mutable Vector s a)
    basicUnsafeThaw = (Vector a -> ST s (MVector s a)) -> Vector a -> ST s (MVector s a)
    forall a b. Coercible a b => a -> b
    coerce (forall (v :: * -> *) a s. Vector v a => v a -> ST s (Mutable v s a)
    G.basicUnsafeThaw @V.Vector @a)
      {-# INLINE basicLength #-}
      basicLength :: Vector a -> Int
    basicLength = (Vector a -> Int) -> Vector a -> Int
    forall a b. Coercible a b => a -> b
    coerce (forall (v :: * -> *) a. Vector v a => v a -> Int
    G.basicLength @V.Vector @a)
      {-# INLINE basicUnsafeSlice #-}
      basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a
    basicUnsafeSlice = (Int -> Int -> Vector a -> Vector a)
    -> Int -> Int -> Vector a -> Vector a
    forall a b. Coercible a b => a -> b
    coerce (forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    G.basicUnsafeSlice @V.Vector @a)
      {-# INLINE basicUnsafeIndexM #-}
      basicUnsafeIndexM :: Vector a -> Int -> Box a
    basicUnsafeIndexM = (Vector a -> Int -> Box a) -> Vector a -> Int -> Box a
    forall a b. Coercible a b => a -> b
    coerce (forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    G.basicUnsafeIndexM @V.Vector @a)
      {-# INLINE basicUnsafeCopy #-}
      basicUnsafeCopy :: forall s. Mutable Vector s a -> Vector a -> ST s ()
    basicUnsafeCopy = (MVector s a -> Vector a -> ST s ())
    -> MVector s a -> Vector a -> ST s ()
    forall a b. Coercible a b => a -> b
    coerce (forall (v :: * -> *) a s.
    Vector v a =>
    Mutable v s a -> v a -> ST s ()
    G.basicUnsafeCopy @V.Vector @a)
      {-# INLINE elemseq #-}
      elemseq :: forall b. Vector a -> a -> b -> b
    elemseq Vector a
    _ = a -> b -> b
    forall a b. a -> b -> b
    seq

    -- See NOTE: [GND for strict vector]
    --
    -- Deriving strategies are only available since 8.2. So we can't use
    -- deriving newtype until we drop support for 8.0
    instance Eq a => Eq (Vector a) where
      {-# INLINE (==) #-}
      == :: Vector a -> Vector a -> Bool
    (==) = (Vector a -> Vector a -> Bool) -> Vector a -> Vector a -> Bool
    forall a b. Coercible a b => a -> b
    coerce (forall a. Eq a => a -> a -> Bool
    (==) @(V.Vector a))

    -- See NOTE: [GND for strict vector]
    instance Ord a => Ord (Vector a) where
      {-# INLINE compare #-}
      compare :: Vector a -> Vector a -> Ordering
    compare = (Vector a -> Vector a -> Ordering)
    -> Vector a -> Vector a -> Ordering
    forall a b. Coercible a b => a -> b
    coerce (forall a. Ord a => a -> a -> Ordering
    compare @(V.Vector a))
      {-# INLINE (<) #-}
      < :: Vector a -> Vector a -> Bool
    (<)  = (Vector a -> Vector a -> Bool) -> Vector a -> Vector a -> Bool
    forall a b. Coercible a b => a -> b
    coerce (forall a. Ord a => a -> a -> Bool
    (<)  @(V.Vector a))
      {-# INLINE (<=) #-}
      <= :: Vector a -> Vector a -> Bool
    (<=) = (Vector a -> Vector a -> Bool) -> Vector a -> Vector a -> Bool
    forall a b. Coercible a b => a -> b
    coerce (forall a. Ord a => a -> a -> Bool
    (<=) @(V.Vector a))
      {-# INLINE (>) #-}
      > :: Vector a -> Vector a -> Bool
    (>)  = (Vector a -> Vector a -> Bool) -> Vector a -> Vector a -> Bool
    forall a b. Coercible a b => a -> b
    coerce (forall a. Ord a => a -> a -> Bool
    (>)  @(V.Vector a))
      {-# INLINE (>=) #-}
      >= :: Vector a -> Vector a -> Bool
    (>=) = (Vector a -> Vector a -> Bool) -> Vector a -> Vector a -> Bool
    forall a b. Coercible a b => a -> b
    coerce (forall a. Ord a => a -> a -> Bool
    (>=) @(V.Vector a))

    instance Eq1 Vector where
      liftEq :: forall a b. (a -> b -> Bool) -> Vector a -> Vector b -> Bool
    liftEq a -> b -> Bool
    eq Vector a
    xs Vector b
    ys = (a -> b -> Bool) -> Bundle Vector a -> Bundle Vector b -> Bool
    forall a b (v :: * -> *).
    (a -> b -> Bool) -> Bundle v a -> Bundle v b -> Bool
    Bundle.eqBy a -> b -> Bool
    eq (Vector a -> Bundle Vector a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    G.stream Vector a
    xs) (Vector b -> Bundle Vector b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    G.stream Vector b
    ys)

    instance Ord1 Vector where
      liftCompare :: forall a b.
    (a -> b -> Ordering) -> Vector a -> Vector b -> Ordering
    liftCompare a -> b -> Ordering
    cmp Vector a
    xs Vector b
    ys = (a -> b -> Ordering)
    -> Bundle Vector a -> Bundle Vector b -> Ordering
    forall a b (v :: * -> *).
    (a -> b -> Ordering) -> Bundle v a -> Bundle v b -> Ordering
    Bundle.cmpBy a -> b -> Ordering
    cmp (Vector a -> Bundle Vector a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    G.stream Vector a
    xs) (Vector b -> Bundle Vector b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    G.stream Vector b
    ys)

    instance Functor Vector where
      {-# INLINE fmap #-}
      fmap :: forall a b. (a -> b) -> Vector a -> Vector b
    fmap = (a -> b) -> Vector a -> Vector b
    forall a b. (a -> b) -> Vector a -> Vector b
    map

      {-# INLINE (<$) #-}
      <$ :: forall a b. a -> Vector b -> Vector a
    (<$) = (b -> a) -> Vector b -> Vector a
    forall a b. (a -> b) -> Vector a -> Vector b
    map ((b -> a) -> Vector b -> Vector a)
    -> (a -> b -> a) -> a -> Vector b -> Vector a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> b -> a
    forall a b. a -> b -> a
    const

    instance Monad Vector where
      {-# INLINE return #-}
      return :: forall a. a -> Vector a
    return = a -> Vector a
    forall a. a -> Vector a
    forall (f :: * -> *) a. Applicative f => a -> f a
    Applicative.pure

      {-# INLINE (>>=) #-}
      >>= :: forall a b. Vector a -> (a -> Vector b) -> Vector b
    (>>=) = ((a -> Vector b) -> Vector a -> Vector b)
    -> Vector a -> (a -> Vector b) -> Vector b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (a -> Vector b) -> Vector a -> Vector b
    forall a b. (a -> Vector b) -> Vector a -> Vector b
    concatMap

    #if !(MIN_VERSION_base(4,13,0))
      {-# INLINE fail #-}
      fail = Fail.fail -- == \ _str -> empty
    #endif

    -- | @since 0.13.2.0
    instance Fail.MonadFail Vector where
      {-# INLINE fail #-}
      fail :: forall a. String -> Vector a
    fail String
    _ = Vector a
    forall a. Vector a
    empty

    instance MonadPlus Vector where
      {-# INLINE mzero #-}
      mzero :: forall a. Vector a
    mzero = Vector a
    forall a. Vector a
    empty

      {-# INLINE mplus #-}
      mplus :: forall a. Vector a -> Vector a -> Vector a
    mplus = Vector a -> Vector a -> Vector a
    forall a. Vector a -> Vector a -> Vector a
    (++)

    instance MonadZip Vector where
      {-# INLINE mzip #-}
      mzip :: forall a b. Vector a -> Vector b -> Vector (a, b)
    mzip = Vector a -> Vector b -> Vector (a, b)
    forall a b. Vector a -> Vector b -> Vector (a, b)
    zip

      {-# INLINE mzipWith #-}
      mzipWith :: forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
    mzipWith = (a -> b -> c) -> Vector a -> Vector b -> Vector c
    forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
    zipWith

      {-# INLINE munzip #-}
      munzip :: forall a b. Vector (a, b) -> (Vector a, Vector b)
    munzip = Vector (a, b) -> (Vector a, Vector b)
    forall a b. Vector (a, b) -> (Vector a, Vector b)
    unzip

    -- | This instance has the same semantics as the one for lists.
    --
    --  @since 0.13.2.0
    instance MonadFix Vector where
      -- We take care to dispose of v0 as soon as possible (see headM docs).
      --
      -- It's perfectly safe to use non-monadic indexing within generate
      -- call since intermediate vector won't be created until result's
      -- value is demanded.
      {-# INLINE mfix #-}
      mfix :: forall a. (a -> Vector a) -> Vector a
    mfix a -> Vector a
    f
        | Vector a -> Bool
    forall a. Vector a -> Bool
    null Vector a
    v0 = Vector a
    forall a. Vector a
    empty
        -- We take first element of resulting vector from v0 and create
        -- rest using generate. Note that cons should fuse with generate
        | Bool
    otherwise = (forall s. ST s (Vector a)) -> Vector a
    forall a. (forall s. ST s a) -> a
    runST ((forall s. ST s (Vector a)) -> Vector a)
    -> (forall s. ST s (Vector a)) -> Vector a
    forall a b. (a -> b) -> a -> b
    $ do
            h <- Vector a -> ST s a
    forall (m :: * -> *) a. Monad m => Vector a -> m a
    headM Vector a
    v0
            return $ cons h $
              generate (lv0 - 1) $
                \Int
    i -> (a -> a) -> a
    forall a. (a -> a) -> a
    fix (\a
    a -> a -> Vector a
    f a
    a Vector a -> Int -> a
    forall a. Vector a -> Int -> a
    ! (Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1))
        where
          -- Used to calculate size of resulting vector
          v0 :: Vector a
    v0 = (Vector a -> Vector a) -> Vector a
    forall a. (a -> a) -> a
    fix (a -> Vector a
    f (a -> Vector a) -> (Vector a -> a) -> Vector a -> Vector a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Vector a -> a
    forall a. Vector a -> a
    head)
          !lv0 :: Int
    lv0 = Vector a -> Int
    forall a. Vector a -> Int
    length Vector a
    v0

    instance Applicative.Applicative Vector where
      {-# INLINE pure #-}
      pure :: forall a. a -> Vector a
    pure = a -> Vector a
    forall a. a -> Vector a
    singleton

      {-# INLINE (<*>) #-}
      <*> :: forall a b. Vector (a -> b) -> Vector a -> Vector b
    (<*>) = Vector (a -> b) -> Vector a -> Vector b
    forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
    ap

    instance Applicative.Alternative Vector where
      {-# INLINE empty #-}
      empty :: forall a. Vector a
    empty = Vector a
    forall a. Vector a
    empty

      {-# INLINE (<|>) #-}
      <|> :: forall a. Vector a -> Vector a -> Vector a
    (<|>) = Vector a -> Vector a -> Vector a
    forall a. Vector a -> Vector a -> Vector a
    (++)

    instance Traversable.Traversable Vector where
      {-# INLINE traverse #-}
      traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Vector a -> f (Vector b)
    traverse a -> f b
    f Vector a
    xs =
          -- Get the length of the vector in /O(1)/ time
          let !n :: Int
    n = Vector a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    G.length Vector a
    xs
          -- Use fromListN to be more efficient in construction of resulting vector
          -- Also behaves better with compact regions, preventing runtime exceptions
          in  Int -> [b] -> Vector b
    forall a. Int -> [a] -> Vector a
    Data.Vector.Strict.fromListN Int
    n ([b] -> Vector b) -> f [b] -> f (Vector b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    Applicative.<$> (a -> f b) -> [a] -> f [b]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    Traversable.traverse a -> f b
    f (Vector a -> [a]
    forall a. Vector a -> [a]
    toList Vector a
    xs)

      {-# INLINE mapM #-}
      mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Vector a -> m (Vector b)
    mapM = (a -> m b) -> Vector a -> m (Vector b)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Vector a -> m (Vector b)
    mapM

      {-# INLINE sequence #-}
      sequence :: forall (m :: * -> *) a. Monad m => Vector (m a) -> m (Vector a)
    sequence = Vector (m a) -> m (Vector a)
    forall (m :: * -> *) a. Monad m => Vector (m a) -> m (Vector a)
    sequence

    -- Length information
    -- ------------------

    -- | /O(1)/ Yield the length of the vector.
    --
    -- @since 0.13.2.0
    length :: Vector a -> Int
    {-# INLINE length #-}
    length :: forall a. Vector a -> Int
    length = Vector a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    G.length

    -- | /O(1)/ Test whether a vector is empty.
    --
    -- @since 0.13.2.0
    null :: Vector a -> Bool
    {-# INLINE null #-}
    null :: forall a. Vector a -> Bool
    null = Vector a -> Bool
    forall (v :: * -> *) a. Vector v a => v a -> Bool
    G.null

    -- Indexing
    -- --------

    -- | O(1) Indexing.
    --
    -- @since 0.13.2.0
    (!) :: Vector a -> Int -> a
    {-# INLINE (!) #-}
    ! :: forall a. Vector a -> Int -> a
    (!) = Vector a -> Int -> a
    forall (v :: * -> *) a.
    (HasCallStack, Vector v a) =>
    v a -> Int -> a
    (G.!)

    -- | O(1) Safe indexing.
    --
    -- @since 0.13.2.0
    (!?) :: Vector a -> Int -> Maybe a
    {-# INLINE (!?) #-}
    !? :: forall a. Vector a -> Int -> Maybe a
    (!?) = Vector a -> Int -> Maybe a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Maybe a
    (G.!?)

    -- | /O(1)/ First element.
    --
    -- @since 0.13.2.0
    head :: Vector a -> a
    {-# INLINE head #-}
    head :: forall a. Vector a -> a
    head = Vector a -> a
    forall (v :: * -> *) a. Vector v a => v a -> a
    G.head

    -- | /O(1)/ Last element.
    --
    -- @since 0.13.2.0
    last :: Vector a -> a
    {-# INLINE last #-}
    last :: forall a. Vector a -> a
    last = Vector a -> a
    forall (v :: * -> *) a. Vector v a => v a -> a
    G.last

    -- | /O(1)/ Unsafe indexing without bounds checking.
    --
    -- @since 0.13.2.0
    unsafeIndex :: Vector a -> Int -> a
    {-# INLINE unsafeIndex #-}
    unsafeIndex :: forall a. Vector a -> Int -> a
    unsafeIndex = Vector a -> Int -> a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> a
    G.unsafeIndex

    -- | /O(1)/ First element, without checking if the vector is empty.
    --
    -- @since 0.13.2.0
    unsafeHead :: Vector a -> a
    {-# INLINE unsafeHead #-}
    unsafeHead :: forall a. Vector a -> a
    unsafeHead = Vector a -> a
    forall (v :: * -> *) a. Vector v a => v a -> a
    G.unsafeHead

    -- | /O(1)/ Last element, without checking if the vector is empty.
    --
    -- @since 0.13.2.0
    unsafeLast :: Vector a -> a
    {-# INLINE unsafeLast #-}
    unsafeLast :: forall a. Vector a -> a
    unsafeLast = Vector a -> a
    forall (v :: * -> *) a. Vector v a => v a -> a
    G.unsafeLast

    -- Monadic indexing
    -- ----------------

    -- | /O(1)/ Indexing in a monad.
    --
    -- The monad allows operations to be strict in the vector when necessary.
    -- Suppose vector copying is implemented like this:
    --
    -- > copy mv v = ... write mv i (v ! i) ...
    --
    -- For lazy vectors, @v ! i@ would not be evaluated which means that @mv@
    -- would unnecessarily retain a reference to @v@ in each element written.
    --
    -- With 'indexM', copying can be implemented like this instead:
    --
    -- > copy mv v = ... do
    -- >                   x <- indexM v i
    -- >                   write mv i x
    --
    -- Here, no references to @v@ are retained because indexing (but /not/ the
    -- element) is evaluated eagerly.
    --
    -- @since 0.13.2.0
    indexM :: Monad m => Vector a -> Int -> m a
    {-# INLINE indexM #-}
    indexM :: forall (m :: * -> *) a. Monad m => Vector a -> Int -> m a
    indexM = Vector a -> Int -> m a
    forall (v :: * -> *) a (m :: * -> *).
    (HasCallStack, Vector v a, Monad m) =>
    v a -> Int -> m a
    G.indexM

    -- | /O(1)/ First element of a vector in a monad. See 'indexM' for an
    -- explanation of why this is useful.
    --
    -- @since 0.13.2.0
    headM :: Monad m => Vector a -> m a
    {-# INLINE headM #-}
    headM :: forall (m :: * -> *) a. Monad m => Vector a -> m a
    headM = Vector a -> m a
    forall (v :: * -> *) a (m :: * -> *).
    (Vector v a, Monad m) =>
    v a -> m a
    G.headM

    -- | /O(1)/ Last element of a vector in a monad. See 'indexM' for an
    -- explanation of why this is useful.
    --
    -- @since 0.13.2.0
    lastM :: Monad m => Vector a -> m a
    {-# INLINE lastM #-}
    lastM :: forall (m :: * -> *) a. Monad m => Vector a -> m a
    lastM = Vector a -> m a
    forall (v :: * -> *) a (m :: * -> *).
    (Vector v a, Monad m) =>
    v a -> m a
    G.lastM

    -- | /O(1)/ Indexing in a monad, without bounds checks. See 'indexM' for an
    -- explanation of why this is useful.
    --
    -- @since 0.13.2.0
    unsafeIndexM :: Monad m => Vector a -> Int -> m a
    {-# INLINE unsafeIndexM #-}
    unsafeIndexM :: forall (m :: * -> *) a. Monad m => Vector a -> Int -> m a
    unsafeIndexM = Vector a -> Int -> m a
    forall (v :: * -> *) a (m :: * -> *).
    (Vector v a, Monad m) =>
    v a -> Int -> m a
    G.unsafeIndexM

    -- | /O(1)/ First element in a monad, without checking for empty vectors.
    -- See 'indexM' for an explanation of why this is useful.
    --
    -- @since 0.13.2.0
    unsafeHeadM :: Monad m => Vector a -> m a
    {-# INLINE unsafeHeadM #-}
    unsafeHeadM :: forall (m :: * -> *) a. Monad m => Vector a -> m a
    unsafeHeadM = Vector a -> m a
    forall (v :: * -> *) a (m :: * -> *).
    (Vector v a, Monad m) =>
    v a -> m a
    G.unsafeHeadM

    -- | /O(1)/ Last element in a monad, without checking for empty vectors.
    -- See 'indexM' for an explanation of why this is useful.
    --
    -- @since 0.13.2.0
    unsafeLastM :: Monad m => Vector a -> m a
    {-# INLINE unsafeLastM #-}
    unsafeLastM :: forall (m :: * -> *) a. Monad m => Vector a -> m a
    unsafeLastM = Vector a -> m a
    forall (v :: * -> *) a (m :: * -> *).
    (Vector v a, Monad m) =>
    v a -> m a
    G.unsafeLastM

    -- Extracting subvectors (slicing)
    -- -------------------------------

    -- | /O(1)/ Yield a slice of the vector without copying it. The vector must
    -- contain at least @i+n@ elements.
    --
    -- @since 0.13.2.0
    slice :: Int   -- ^ @i@ starting index
                     -> Int   -- ^ @n@ length
                     -> Vector a
                     -> Vector a
    {-# INLINE slice #-}
    slice :: forall a. Int -> Int -> Vector a -> Vector a
    slice = Int -> Int -> Vector a -> Vector a
    forall (v :: * -> *) a.
    (HasCallStack, Vector v a) =>
    Int -> Int -> v a -> v a
    G.slice

    -- | /O(1)/ Yield all but the last element without copying. The vector may not
    -- be empty.
    --
    -- @since 0.13.2.0
    init :: Vector a -> Vector a
    {-# INLINE init #-}
    init :: forall a. Vector a -> Vector a
    init = Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => v a -> v a
    G.init

    -- | /O(1)/ Yield all but the first element without copying. The vector may not
    -- be empty.
    --
    -- @since 0.13.2.0
    tail :: Vector a -> Vector a
    {-# INLINE tail #-}
    tail :: forall a. Vector a -> Vector a
    tail = Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => v a -> v a
    G.tail

    -- | /O(1)/ Yield at the first @n@ elements without copying. The vector may
    -- contain less than @n@ elements, in which case it is returned unchanged.
    --
    -- @since 0.13.2.0
    take :: Int -> Vector a -> Vector a
    {-# INLINE take #-}
    take :: forall a. Int -> Vector a -> Vector a
    take = Int -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
    G.take

    -- | /O(1)/ Yield all but the first @n@ elements without copying. The vector may
    -- contain less than @n@ elements, in which case an empty vector is returned.
    --
    -- @since 0.13.2.0
    drop :: Int -> Vector a -> Vector a
    {-# INLINE drop #-}
    drop :: forall a. Int -> Vector a -> Vector a
    drop = Int -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
    G.drop

    -- | /O(1)/ Yield the first @n@ elements paired with the remainder, without copying.
    --
    -- Note that @'splitAt' n v@ is equivalent to @('take' n v, 'drop' n v)@,
    -- but slightly more efficient.
    --
    -- @since 0.13.2.0
    splitAt :: Int -> Vector a -> (Vector a, Vector a)
    {-# INLINE splitAt #-}
    splitAt :: forall a. Int -> Vector a -> (Vector a, Vector a)
    splitAt = Int -> Vector a -> (Vector a, Vector a)
    forall (v :: * -> *) a. Vector v a => Int -> v a -> (v a, v a)
    G.splitAt

    -- | /O(1)/ Yield the 'head' and 'tail' of the vector, or 'Nothing' if
    -- the vector is empty.
    --
    -- @since 0.13.2.0
    uncons :: Vector a -> Maybe (a, Vector a)
    {-# INLINE uncons #-}
    uncons :: forall a. Vector a -> Maybe (a, Vector a)
    uncons = Vector a -> Maybe (a, Vector a)
    forall (v :: * -> *) a. Vector v a => v a -> Maybe (a, v a)
    G.uncons

    -- | /O(1)/ Yield the 'last' and 'init' of the vector, or 'Nothing' if
    -- the vector is empty.
    --
    -- @since 0.13.2.0
    unsnoc :: Vector a -> Maybe (Vector a, a)
    {-# INLINE unsnoc #-}
    unsnoc :: forall a. Vector a -> Maybe (Vector a, a)
    unsnoc = Vector a -> Maybe (Vector a, a)
    forall (v :: * -> *) a. Vector v a => v a -> Maybe (v a, a)
    G.unsnoc

    -- | /O(1)/ Yield a slice of the vector without copying. The vector must
    -- contain at least @i+n@ elements, but this is not checked.
    --
    -- @since 0.13.2.0
    unsafeSlice :: Int   -- ^ @i@ starting index
                           -> Int   -- ^ @n@ length
                           -> Vector a
                           -> Vector a
    {-# INLINE unsafeSlice #-}
    unsafeSlice :: forall a. Int -> Int -> Vector a -> Vector a
    unsafeSlice = Int -> Int -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    G.unsafeSlice

    -- | /O(1)/ Yield all but the last element without copying. The vector may not
    -- be empty, but this is not checked.
    --
    -- @since 0.13.2.0
    unsafeInit :: Vector a -> Vector a
    {-# INLINE unsafeInit #-}
    unsafeInit :: forall a. Vector a -> Vector a
    unsafeInit = Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => v a -> v a
    G.unsafeInit

    -- | /O(1)/ Yield all but the first element without copying. The vector may not
    -- be empty, but this is not checked.
    --
    -- @since 0.13.2.0
    unsafeTail :: Vector a -> Vector a
    {-# INLINE unsafeTail #-}
    unsafeTail :: forall a. Vector a -> Vector a
    unsafeTail = Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => v a -> v a
    G.unsafeTail

    -- | /O(1)/ Yield the first @n@ elements without copying. The vector must
    -- contain at least @n@ elements, but this is not checked.
    --
    -- @since 0.13.2.0
    unsafeTake :: Int -> Vector a -> Vector a
    {-# INLINE unsafeTake #-}
    unsafeTake :: forall a. Int -> Vector a -> Vector a
    unsafeTake = Int -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
    G.unsafeTake

    -- | /O(1)/ Yield all but the first @n@ elements without copying. The vector
    -- must contain at least @n@ elements, but this is not checked.
    --
    -- @since 0.13.2.0
    unsafeDrop :: Int -> Vector a -> Vector a
    {-# INLINE unsafeDrop #-}
    unsafeDrop :: forall a. Int -> Vector a -> Vector a
    unsafeDrop = Int -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
    G.unsafeDrop

    -- Initialisation
    -- --------------

    -- | /O(1)/ The empty vector.
    --
    -- @since 0.13.2.0
    empty :: Vector a
    {-# INLINE empty #-}
    empty :: forall a. Vector a
    empty = Vector a
    forall (v :: * -> *) a. Vector v a => v a
    G.empty

    -- | /O(1)/ A vector with exactly one element.
    --
    -- @since 0.13.2.0
    singleton :: a -> Vector a
    {-# INLINE singleton #-}
    singleton :: forall a. a -> Vector a
    singleton = a -> Vector a
    forall (v :: * -> *) a. Vector v a => a -> v a
    G.singleton

    -- | /O(n)/ A vector of the given length with the same value in each position.
    --
    -- @since 0.13.2.0
    replicate :: Int -> a -> Vector a
    {-# INLINE replicate #-}
    replicate :: forall a. Int -> a -> Vector a
    replicate = Int -> a -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> a -> v a
    G.replicate

    -- | /O(n)/ Construct a vector of the given length by applying the function to
    -- each index.
    --
    -- @since 0.13.2.0
    generate :: Int -> (Int -> a) -> Vector a
    {-# INLINE generate #-}
    generate :: forall a. Int -> (Int -> a) -> Vector a
    generate = Int -> (Int -> a) -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> (Int -> a) -> v a
    G.generate

    -- | /O(n)/ Apply the function \(\max(n - 1, 0)\) times to an initial value, producing a vector
    -- of length \(\max(n, 0)\). The 0th element will contain the initial value, which is why there
    -- is one less function application than the number of elements in the produced vector.
    --
    -- \( \underbrace{x, f (x), f (f (x)), \ldots}_{\max(0,n)\rm{~elements}} \)
    --
    -- ===__Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.iterateN 0 undefined undefined :: V.Vector String
    -- []
    -- >>> V.iterateN 4 (\x -> x <> x) "Hi"
    -- ["Hi","HiHi","HiHiHiHi","HiHiHiHiHiHiHiHi"]
    --
    -- @since 0.13.2.0
    iterateN :: Int -> (a -> a) -> a -> Vector a
    {-# INLINE iterateN #-}
    iterateN :: forall a. Int -> (a -> a) -> a -> Vector a
    iterateN = Int -> (a -> a) -> a -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> (a -> a) -> a -> v a
    G.iterateN

    -- Unfolding
    -- ---------

    -- | /O(n)/ Construct a 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.
    --
    -- > unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10
    -- >  = <10,9,8,7,6,5,4,3,2,1>
    --
    -- @since 0.13.2.0
    unfoldr :: (b -> Maybe (a, b)) -> b -> Vector a
    {-# INLINE unfoldr #-}
    unfoldr :: forall b a. (b -> Maybe (a, b)) -> b -> Vector a
    unfoldr = (b -> Maybe (a, b)) -> b -> Vector a
    forall (v :: * -> *) a b.
    Vector v a =>
    (b -> Maybe (a, b)) -> b -> v a
    G.unfoldr

    -- | /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.
    --
    -- > unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8>
    --
    -- @since 0.13.2.0
    unfoldrN :: Int -> (b -> Maybe (a, b)) -> b -> Vector a
    {-# INLINE unfoldrN #-}
    unfoldrN :: forall b a. Int -> (b -> Maybe (a, b)) -> b -> Vector a
    unfoldrN = Int -> (b -> Maybe (a, b)) -> b -> Vector a
    forall (v :: * -> *) a b.
    Vector v a =>
    Int -> (b -> Maybe (a, b)) -> b -> v a
    G.unfoldrN

    -- | /O(n)/ Construct a vector with exactly @n@ elements by repeatedly applying
    -- the generator function to a seed. The generator function yields the
    -- next element and the new seed.
    --
    -- > unfoldrExactN 3 (\n -> (n,n-1)) 10 = <10,9,8>
    --
    -- @since 0.13.2.0
    unfoldrExactN  :: Int -> (b -> (a, b)) -> b -> Vector a
    {-# INLINE unfoldrExactN #-}
    unfoldrExactN :: forall b a. Int -> (b -> (a, b)) -> b -> Vector a
    unfoldrExactN = Int -> (b -> (a, b)) -> b -> Vector a
    forall (v :: * -> *) a b.
    Vector v a =>
    Int -> (b -> (a, b)) -> b -> v a
    G.unfoldrExactN

    -- | /O(n)/ Construct a 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.
    --
    -- @since 0.13.2.0
    unfoldrM :: (Monad m) => (b -> m (Maybe (a, b))) -> b -> m (Vector a)
    {-# INLINE unfoldrM #-}
    unfoldrM :: forall (m :: * -> *) b a.
    Monad m =>
    (b -> m (Maybe (a, b))) -> b -> m (Vector a)
    unfoldrM = (b -> m (Maybe (a, b))) -> b -> m (Vector a)
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    (b -> m (Maybe (a, b))) -> b -> m (v a)
    G.unfoldrM

    -- | /O(n)/ Construct a 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.
    --
    -- @since 0.13.2.0
    unfoldrNM :: (Monad m) => Int -> (b -> m (Maybe (a, b))) -> b -> m (Vector a)
    {-# INLINE unfoldrNM #-}
    unfoldrNM :: forall (m :: * -> *) b a.
    Monad m =>
    Int -> (b -> m (Maybe (a, b))) -> b -> m (Vector a)
    unfoldrNM = Int -> (b -> m (Maybe (a, b))) -> b -> m (Vector a)
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    Int -> (b -> m (Maybe (a, b))) -> b -> m (v a)
    G.unfoldrNM

    -- | /O(n)/ Construct a vector with exactly @n@ elements by repeatedly
    -- applying the monadic generator function to a seed. The generator
    -- function yields the next element and the new seed.
    --
    -- @since 0.13.2.0
    unfoldrExactNM :: (Monad m) => Int -> (b -> m (a, b)) -> b -> m (Vector a)
    {-# INLINE unfoldrExactNM #-}
    unfoldrExactNM :: forall (m :: * -> *) b a.
    Monad m =>
    Int -> (b -> m (a, b)) -> b -> m (Vector a)
    unfoldrExactNM = Int -> (b -> m (a, b)) -> b -> m (Vector a)
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    Int -> (b -> m (a, b)) -> b -> m (v a)
    G.unfoldrExactNM

    -- | /O(n)/ Construct a vector with @n@ elements by repeatedly applying the
    -- generator function to the already constructed part of the vector.
    --
    -- > constructN 3 f = let a = f <> ; b = f <a> ; c = f <a,b> in <a,b,c>
    --
    -- @since 0.13.2.0
    constructN :: Int -> (Vector a -> a) -> Vector a
    {-# INLINE constructN #-}
    constructN :: forall a. Int -> (Vector a -> a) -> Vector a
    constructN = Int -> (Vector a -> a) -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> (v a -> a) -> v a
    G.constructN

    -- | /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.
    --
    -- > constructrN 3 f = let a = f <> ; b = f<a> ; c = f <b,a> in <c,b,a>
    --
    -- @since 0.13.2.0
    constructrN :: Int -> (Vector a -> a) -> Vector a
    {-# INLINE constructrN #-}
    constructrN :: forall a. Int -> (Vector a -> a) -> Vector a
    constructrN = Int -> (Vector a -> a) -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> (v a -> a) -> v a
    G.constructrN

    -- Enumeration
    -- -----------

    -- | /O(n)/ Yield a vector of the given length, containing the values @x@, @x+1@
    -- etc. This operation is usually more efficient than 'enumFromTo'.
    --
    -- > enumFromN 5 3 = <5,6,7>
    --
    -- @since 0.13.2.0
    enumFromN :: Num a => a -> Int -> Vector a
    {-# INLINE enumFromN #-}
    enumFromN :: forall a. Num a => a -> Int -> Vector a
    enumFromN = a -> Int -> Vector a
    forall (v :: * -> *) a. (Vector v a, Num a) => a -> Int -> v a
    G.enumFromN

    -- | /O(n)/ Yield a vector of the given length, containing the values @x@, @x+y@,
    -- @x+y+y@ etc. This operations is usually more efficient than 'enumFromThenTo'.
    --
    -- > enumFromStepN 1 2 5 = <1,3,5,7,9>
    --
    -- @since 0.13.2.0
    enumFromStepN :: Num a => a -> a -> Int -> Vector a
    {-# INLINE enumFromStepN #-}
    enumFromStepN :: forall a. Num a => a -> a -> Int -> Vector a
    enumFromStepN = a -> a -> Int -> Vector a
    forall (v :: * -> *) a. (Vector v a, Num a) => a -> a -> Int -> v a
    G.enumFromStepN

    -- | /O(n)/ Enumerate values from @x@ to @y@.
    --
    -- /WARNING:/ This operation can be very inefficient. If possible, use
    -- 'enumFromN' instead.
    --
    -- @since 0.13.2.0
    enumFromTo :: Enum a => a -> a -> Vector a
    {-# INLINE enumFromTo #-}
    enumFromTo :: forall a. Enum a => a -> a -> Vector a
    enumFromTo = a -> a -> Vector a
    forall (v :: * -> *) a. (Vector v a, Enum a) => a -> a -> v a
    G.enumFromTo

    -- | /O(n)/ Enumerate values from @x@ to @y@ with a specific step @z@.
    --
    -- /WARNING:/ This operation can be very inefficient. If possible, use
    -- 'enumFromStepN' instead.
    --
    -- @since 0.13.2.0
    enumFromThenTo :: Enum a => a -> a -> a -> Vector a
    {-# INLINE enumFromThenTo #-}
    enumFromThenTo :: forall a. Enum a => a -> a -> a -> Vector a
    enumFromThenTo = a -> a -> a -> Vector a
    forall (v :: * -> *) a. (Vector v a, Enum a) => a -> a -> a -> v a
    G.enumFromThenTo

    -- Concatenation
    -- -------------

    -- | /O(n)/ Prepend an element.
    --
    -- @since 0.13.2.0
    cons :: a -> Vector a -> Vector a
    {-# INLINE cons #-}
    cons :: forall a. a -> Vector a -> Vector a
    cons = a -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => a -> v a -> v a
    G.cons

    -- | /O(n)/ Append an element.
    --
    -- @since 0.13.2.0
    snoc :: Vector a -> a -> Vector a
    {-# INLINE snoc #-}
    snoc :: forall a. Vector a -> a -> Vector a
    snoc = Vector a -> a -> Vector a
    forall (v :: * -> *) a. Vector v a => v a -> a -> v a
    G.snoc

    infixr 5 ++
    -- | /O(m+n)/ Concatenate two vectors.
    --
    -- @since 0.13.2.0
    (++) :: Vector a -> Vector a -> Vector a
    {-# INLINE (++) #-}
    ++ :: forall a. Vector a -> Vector a -> Vector a
    (++) = Vector a -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => v a -> v a -> v a
    (G.++)

    -- | /O(n)/ Concatenate all vectors in the list.
    --
    -- @since 0.13.2.0
    concat :: [Vector a] -> Vector a
    {-# INLINE concat #-}
    concat :: forall a. [Vector a] -> Vector a
    concat = [Vector a] -> Vector a
    forall (v :: * -> *) a. Vector v a => [v a] -> v a
    G.concat

    -- Monadic initialisation
    -- ----------------------

    -- | /O(n)/ Execute the monadic action the given number of times and store the
    -- results in a vector.
    --
    -- @since 0.13.2.0
    replicateM :: Monad m => Int -> m a -> m (Vector a)
    {-# INLINE replicateM #-}
    replicateM :: forall (m :: * -> *) a. Monad m => Int -> m a -> m (Vector a)
    replicateM = Int -> m a -> m (Vector a)
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    Int -> m a -> m (v a)
    G.replicateM

    -- | /O(n)/ Construct a vector of the given length by applying the monadic
    -- action to each index.
    --
    -- @since 0.13.2.0
    generateM :: Monad m => Int -> (Int -> m a) -> m (Vector a)
    {-# INLINE generateM #-}
    generateM :: forall (m :: * -> *) a.
    Monad m =>
    Int -> (Int -> m a) -> m (Vector a)
    generateM = Int -> (Int -> m a) -> m (Vector a)
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    Int -> (Int -> m a) -> m (v a)
    G.generateM

    -- | /O(n)/ Apply the monadic function \(\max(n - 1, 0)\) times to an initial value, producing a vector
    -- of length \(\max(n, 0)\). The 0th element will contain the initial value, which is why there
    -- is one less function application than the number of elements in the produced vector.
    --
    -- For a non-monadic version, see `iterateN`.
    --
    -- @since 0.13.2.0
    iterateNM :: Monad m => Int -> (a -> m a) -> a -> m (Vector a)
    {-# INLINE iterateNM #-}
    iterateNM :: forall (m :: * -> *) a.
    Monad m =>
    Int -> (a -> m a) -> a -> m (Vector a)
    iterateNM = Int -> (a -> m a) -> a -> m (Vector a)
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    Int -> (a -> m a) -> a -> m (v a)
    G.iterateNM

    -- | Execute the monadic action and freeze the resulting vector.
    --
    -- @
    -- create (do { v \<- new 2; write v 0 \'a\'; write v 1 \'b\'; return v }) = \<'a','b'\>
    -- @
    --
    -- @since 0.13.2.0
    create :: (forall s. ST s (MVector s a)) -> Vector a
    {-# INLINE create #-}
    -- NOTE: eta-expanded due to http://hackage.haskell.org/trac/ghc/ticket/4120
    create :: forall a. (forall s. ST s (MVector s a)) -> Vector a
    create forall s. ST s (MVector s a)
    p = (forall s. ST s (Mutable Vector s a)) -> Vector a
    forall (v :: * -> *) a.
    Vector v a =>
    (forall s. ST s (Mutable v s a)) -> v a
    G.create ST s (Mutable Vector s a)
    ST s (MVector s a)
    forall s. ST s (Mutable Vector s a)
    forall s. ST s (MVector s a)
    p

    -- | Execute the monadic action and freeze the resulting vectors.
    --
    -- @since 0.13.2.0
    createT :: Traversable.Traversable f => (forall s. ST s (f (MVector s a))) -> f (Vector a)
    {-# INLINE createT #-}
    createT :: forall (f :: * -> *) a.
    Traversable f =>
    (forall s. ST s (f (MVector s a))) -> f (Vector a)
    createT forall s. ST s (f (MVector s a))
    p = (forall s. ST s (f (Mutable Vector s a))) -> f (Vector a)
    forall (f :: * -> *) (v :: * -> *) a.
    (Traversable f, Vector v a) =>
    (forall s. ST s (f (Mutable v s a))) -> f (v a)
    G.createT ST s (f (Mutable Vector s a))
    ST s (f (MVector s a))
    forall s. ST s (f (Mutable Vector s a))
    forall s. ST s (f (MVector s a))
    p

    -- Restricting memory usage
    -- ------------------------

    -- | /O(n)/ Yield the argument, but force it not to retain any extra memory,
    -- by copying it.
    --
    -- This is especially useful when dealing with slices. For example:
    --
    -- > force (slice 0 2 <huge vector>)
    --
    -- 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.
    --
    -- @since 0.13.2.0
    force :: Vector a -> Vector a
    {-# INLINE force #-}
    force :: forall a. Vector a -> Vector a
    force = Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => v a -> v a
    G.force

    -- Bulk updates
    -- ------------

    -- | /O(m+n)/ For each pair @(i,a)@ from the list of index/value pairs,
    -- replace the vector element at position @i@ by @a@.
    --
    -- > <5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>
    --
    -- @since 0.13.2.0
    (//) :: Vector a   -- ^ initial vector (of length @m@)
                    -> [(Int, a)] -- ^ list of index/value pairs (of length @n@)
                    -> Vector a
    {-# INLINE (//) #-}
    // :: forall a. Vector a -> [(Int, a)] -> Vector a
    (//) = Vector a -> [(Int, a)] -> Vector a
    forall (v :: * -> *) a. Vector v a => v a -> [(Int, a)] -> v a
    (G.//)

    -- | /O(m+n)/ For each pair @(i,a)@ from the vector of index/value pairs,
    -- replace the vector element at position @i@ by @a@.
    --
    -- > update <5,9,2,7> <(2,1),(0,3),(2,8)> = <3,9,8,7>
    --
    -- @since 0.13.2.0
    update :: Vector a        -- ^ initial vector (of length @m@)
           -> Vector (Int, a) -- ^ vector of index/value pairs (of length @n@)
           -> Vector a
    {-# INLINE update #-}
    update :: forall a. Vector a -> Vector (Int, a) -> Vector a
    update = Vector a -> Vector (Int, a) -> Vector a
    forall (v :: * -> *) a.
    (Vector v a, Vector v (Int, a)) =>
    v a -> v (Int, a) -> v a
    G.update

    -- | /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_ <5,9,2,7>  <2,0,2> <1,3,8> = <3,9,8,7>
    --
    -- The function 'update' provides the same functionality and is usually more
    -- convenient.
    --
    -- @
    -- update_ xs is ys = 'update' xs ('zip' is ys)
    -- @
    --
    -- @since 0.13.2.0
    update_ :: Vector a   -- ^ initial vector (of length @m@)
            -> Vector Int -- ^ index vector (of length @n1@)
            -> Vector a   -- ^ value vector (of length @n2@)
            -> Vector a
    {-# INLINE update_ #-}
    update_ :: forall a. Vector a -> Vector Int -> Vector a -> Vector a
    update_ = Vector a -> Vector Int -> Vector a -> Vector a
    forall (v :: * -> *) a.
    (Vector v a, Vector v Int) =>
    v a -> v Int -> v a -> v a
    G.update_

    -- | Same as ('//'), but without bounds checking.
    --
    -- @since 0.13.2.0
    unsafeUpd :: Vector a -> [(Int, a)] -> Vector a
    {-# INLINE unsafeUpd #-}
    unsafeUpd :: forall a. Vector a -> [(Int, a)] -> Vector a
    unsafeUpd = Vector a -> [(Int, a)] -> Vector a
    forall (v :: * -> *) a. Vector v a => v a -> [(Int, a)] -> v a
    G.unsafeUpd

    -- | Same as 'update', but without bounds checking.
    --
    -- @since 0.13.2.0
    unsafeUpdate :: Vector a -> Vector (Int, a) -> Vector a
    {-# INLINE unsafeUpdate #-}
    unsafeUpdate :: forall a. Vector a -> Vector (Int, a) -> Vector a
    unsafeUpdate = Vector a -> Vector (Int, a) -> Vector a
    forall (v :: * -> *) a.
    (Vector v a, Vector v (Int, a)) =>
    v a -> v (Int, a) -> v a
    G.unsafeUpdate

    -- | Same as 'update_', but without bounds checking.
    --
    -- @since 0.13.2.0
    unsafeUpdate_ :: Vector a -> Vector Int -> Vector a -> Vector a
    {-# INLINE unsafeUpdate_ #-}
    unsafeUpdate_ :: forall a. Vector a -> Vector Int -> Vector a -> Vector a
    unsafeUpdate_ = Vector a -> Vector Int -> Vector a -> Vector a
    forall (v :: * -> *) a.
    (Vector v a, Vector v Int) =>
    v a -> v Int -> v a -> v a
    G.unsafeUpdate_

    -- Accumulations
    -- -------------

    -- | /O(m+n)/ For each pair @(i,b)@ from the list, replace the vector element
    -- @a@ at position @i@ by @f a b@.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.accum (+) (V.fromList [1000,2000,3000]) [(2,4),(1,6),(0,3),(1,10)]
    -- [1003,2016,3004]
    --
    -- @since 0.13.2.0
    accum :: (a -> b -> a) -- ^ accumulating function @f@
          -> Vector a      -- ^ initial vector (of length @m@)
          -> [(Int,b)]     -- ^ list of index/value pairs (of length @n@)
          -> Vector a
    {-# INLINE accum #-}
    accum :: forall a b. (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
    accum = (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
    forall (v :: * -> *) a b.
    Vector v a =>
    (a -> b -> a) -> v a -> [(Int, b)] -> v a
    G.accum

    -- | /O(m+n)/ For each pair @(i,b)@ from the vector of pairs, replace the vector
    -- element @a@ at position @i@ by @f a b@.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.accumulate (+) (V.fromList [1000,2000,3000]) (V.fromList [(2,4),(1,6),(0,3),(1,10)])
    -- [1003,2016,3004]
    --
    -- @since 0.13.2.0
    accumulate :: (a -> b -> a)  -- ^ accumulating function @f@
                -> Vector a       -- ^ initial vector (of length @m@)
                -> Vector (Int,b) -- ^ vector of index/value pairs (of length @n@)
                -> Vector a
    {-# INLINE accumulate #-}
    accumulate :: forall a b.
    (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
    accumulate = (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v (Int, b)) =>
    (a -> b -> a) -> v a -> v (Int, b) -> v a
    G.accumulate

    -- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
    -- corresponding value @b@ from the value vector,
    -- replace the element of the initial vector at
    -- position @i@ by @f a b@.
    --
    -- > accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>
    --
    -- The function 'accumulate' provides the same functionality and is usually more
    -- convenient.
    --
    -- @
    -- accumulate_ f as is bs = 'accumulate' f as ('zip' is bs)
    -- @
    --
    -- @since 0.13.2.0
    accumulate_ :: (a -> b -> a) -- ^ accumulating function @f@
                -> Vector a      -- ^ initial vector (of length @m@)
                -> Vector Int    -- ^ index vector (of length @n1@)
                -> Vector b      -- ^ value vector (of length @n2@)
                -> Vector a
    {-# INLINE accumulate_ #-}
    accumulate_ :: forall a b.
    (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
    accumulate_ = (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v Int, Vector v b) =>
    (a -> b -> a) -> v a -> v Int -> v b -> v a
    G.accumulate_

    -- | Same as 'accum', but without bounds checking.
    --
    -- @since 0.13.2.0
    unsafeAccum :: (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
    {-# INLINE unsafeAccum #-}
    unsafeAccum :: forall a b. (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
    unsafeAccum = (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
    forall (v :: * -> *) a b.
    Vector v a =>
    (a -> b -> a) -> v a -> [(Int, b)] -> v a
    G.unsafeAccum

    -- | Same as 'accumulate', but without bounds checking.
    --
    -- @since 0.13.2.0
    unsafeAccumulate :: (a -> b -> a) -> Vector a -> Vector (Int,b) -> Vector a
    {-# INLINE unsafeAccumulate #-}
    unsafeAccumulate :: forall a b.
    (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
    unsafeAccumulate = (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v (Int, b)) =>
    (a -> b -> a) -> v a -> v (Int, b) -> v a
    G.unsafeAccumulate

    -- | Same as 'accumulate_', but without bounds checking.
    --
    -- @since 0.13.2.0
    unsafeAccumulate_
      :: (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
    {-# INLINE unsafeAccumulate_ #-}
    unsafeAccumulate_ :: forall a b.
    (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
    unsafeAccumulate_ = (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v Int, Vector v b) =>
    (a -> b -> a) -> v a -> v Int -> v b -> v a
    G.unsafeAccumulate_

    -- Permutations
    -- ------------

    -- | /O(n)/ Reverse a vector.
    --
    -- @since 0.13.2.0
    reverse :: Vector a -> Vector a
    {-# INLINE reverse #-}
    reverse :: forall a. Vector a -> Vector a
    reverse = Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => v a -> v a
    G.reverse

    -- | /O(n)/ Yield the vector obtained by replacing each element @i@ of the
    -- index vector by @xs'!'i@. This is equivalent to @'map' (xs'!') is@, but is
    -- often much more efficient.
    --
    -- > backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>
    --
    -- @since 0.13.2.0
    backpermute :: Vector a -> Vector Int -> Vector a
    {-# INLINE backpermute #-}
    backpermute :: forall a. Vector a -> Vector Int -> Vector a
    backpermute = Vector a -> Vector Int -> Vector a
    forall (v :: * -> *) a.
    (HasCallStack, Vector v a, Vector v Int) =>
    v a -> v Int -> v a
    G.backpermute

    -- | Same as 'backpermute', but without bounds checking.
    --
    -- @since 0.13.2.0
    unsafeBackpermute :: Vector a -> Vector Int -> Vector a
    {-# INLINE unsafeBackpermute #-}
    unsafeBackpermute :: forall a. Vector a -> Vector Int -> Vector a
    unsafeBackpermute = Vector a -> Vector Int -> Vector a
    forall (v :: * -> *) a.
    (Vector v a, Vector v Int) =>
    v a -> v Int -> v a
    G.unsafeBackpermute

    -- Safe destructive updates
    -- ------------------------

    -- | Apply a destructive operation to a vector. The operation may be
    -- performed in place if it is safe to do so and will modify a copy of the
    -- vector otherwise (see 'Data.Vector.Generic.New.New' for details).
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> import qualified Data.Vector.Mutable as MV
    -- >>> V.modify (\v -> MV.write v 0 'x') $ V.replicate 4 'a'
    -- "xaaa"
    --
    -- @since 0.13.2.0
    modify :: (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
    {-# INLINE modify #-}
    modify :: forall a.
    (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
    modify forall s. MVector s a -> ST s ()
    p = (forall s. Mutable Vector s a -> ST s ()) -> Vector a -> Vector a
    forall (v :: * -> *) a.
    Vector v a =>
    (forall s. Mutable v s a -> ST s ()) -> v a -> v a
    G.modify Mutable Vector s a -> ST s ()
    MVector s a -> ST s ()
    forall s. Mutable Vector s a -> ST s ()
    forall s. MVector s a -> ST s ()
    p

    -- Indexing
    -- --------

    -- | /O(n)/ Pair each element in a vector with its index.
    --
    -- @since 0.13.2.0
    indexed :: Vector a -> Vector (Int,a)
    {-# INLINE indexed #-}
    indexed :: forall a. Vector a -> Vector (Int, a)
    indexed = Vector a -> Vector (Int, a)
    forall (v :: * -> *) a.
    (Vector v a, Vector v (Int, a)) =>
    v a -> v (Int, a)
    G.indexed

    -- Mapping
    -- -------

    -- | /O(n)/ Map a function over a vector.
    --
    -- @since 0.13.2.0
    map :: (a -> b) -> Vector a -> Vector b
    {-# INLINE map #-}
    map :: forall a b. (a -> b) -> Vector a -> Vector b
    map = (a -> b) -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    G.map

    -- | /O(n)/ Apply a function to every element of a vector and its index.
    --
    -- @since 0.13.2.0
    imap :: (Int -> a -> b) -> Vector a -> Vector b
    {-# INLINE imap #-}
    imap :: forall a b. (Int -> a -> b) -> Vector a -> Vector b
    imap = (Int -> a -> b) -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> b) -> v a -> v b
    G.imap

    -- | Map a function over a vector and concatenate the results.
    --
    -- @since 0.13.2.0
    concatMap :: (a -> Vector b) -> Vector a -> Vector b
    {-# INLINE concatMap #-}
    concatMap :: forall a b. (a -> Vector b) -> Vector a -> Vector b
    concatMap = (a -> Vector b) -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> v b) -> v a -> v b
    G.concatMap

    -- Monadic mapping
    -- ---------------

    -- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
    -- vector of results.
    --
    -- @since 0.13.2.0
    mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b)
    {-# INLINE mapM #-}
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Vector a -> m (Vector b)
    mapM = (a -> m b) -> Vector a -> m (Vector b)
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a, Vector v b) =>
    (a -> m b) -> v a -> m (v b)
    G.mapM

    -- | /O(n)/ Apply the monadic action to every element of a vector and its
    -- index, yielding a vector of results.
    --
    -- @since 0.13.2.0
    imapM :: Monad m => (Int -> a -> m b) -> Vector a -> m (Vector b)
    {-# INLINE imapM #-}
    imapM :: forall (m :: * -> *) a b.
    Monad m =>
    (Int -> a -> m b) -> Vector a -> m (Vector b)
    imapM = (Int -> a -> m b) -> Vector a -> m (Vector b)
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a, Vector v b) =>
    (Int -> a -> m b) -> v a -> m (v b)
    G.imapM

    -- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
    -- results.
    --
    -- @since 0.13.2.0
    mapM_ :: Monad m => (a -> m b) -> Vector a -> m ()
    {-# INLINE mapM_ #-}
    mapM_ :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Vector a -> m ()
    mapM_ = (a -> m b) -> Vector a -> m ()
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    (a -> m b) -> v a -> m ()
    G.mapM_

    -- | /O(n)/ Apply the monadic action to every element of a vector and its
    -- index, ignoring the results.
    --
    -- @since 0.13.2.0
    imapM_ :: Monad m => (Int -> a -> m b) -> Vector a -> m ()
    {-# INLINE imapM_ #-}
    imapM_ :: forall (m :: * -> *) a b.
    Monad m =>
    (Int -> a -> m b) -> Vector a -> m ()
    imapM_ = (Int -> a -> m b) -> Vector a -> m ()
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    (Int -> a -> m b) -> v a -> m ()
    G.imapM_

    -- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
    -- vector of results. Equivalent to @flip 'mapM'@.
    --
    -- @since 0.13.2.0
    forM :: Monad m => Vector a -> (a -> m b) -> m (Vector b)
    {-# INLINE forM #-}
    forM :: forall (m :: * -> *) a b.
    Monad m =>
    Vector a -> (a -> m b) -> m (Vector b)
    forM = Vector a -> (a -> m b) -> m (Vector b)
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a, Vector v b) =>
    v a -> (a -> m b) -> m (v b)
    G.forM

    -- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the
    -- results. Equivalent to @flip 'mapM_'@.
    --
    -- @since 0.13.2.0
    forM_ :: Monad m => Vector a -> (a -> m b) -> m ()
    {-# INLINE forM_ #-}
    forM_ :: forall (m :: * -> *) a b. Monad m => Vector a -> (a -> m b) -> m ()
    forM_ = Vector a -> (a -> m b) -> m ()
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    v a -> (a -> m b) -> m ()
    G.forM_

    -- | /O(n)/ Apply the monadic action to all elements of the vector and their indices, yielding a
    -- vector of results. Equivalent to @'flip' 'imapM'@.
    --
    -- @since 0.13.2.0
    iforM :: Monad m => Vector a -> (Int -> a -> m b) -> m (Vector b)
    {-# INLINE iforM #-}
    iforM :: forall (m :: * -> *) a b.
    Monad m =>
    Vector a -> (Int -> a -> m b) -> m (Vector b)
    iforM = Vector a -> (Int -> a -> m b) -> m (Vector b)
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a, Vector v b) =>
    v a -> (Int -> a -> m b) -> m (v b)
    G.iforM

    -- | /O(n)/ Apply the monadic action to all elements of the vector and their indices
    -- and ignore the results. Equivalent to @'flip' 'imapM_'@.
    --
    -- @since 0.13.2.0
    iforM_ :: Monad m => Vector a -> (Int -> a -> m b) -> m ()
    {-# INLINE iforM_ #-}
    iforM_ :: forall (m :: * -> *) a b.
    Monad m =>
    Vector a -> (Int -> a -> m b) -> m ()
    iforM_ = Vector a -> (Int -> a -> m b) -> m ()
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    v a -> (Int -> a -> m b) -> m ()
    G.iforM_

    -- Zipping
    -- -------

    -- | /O(min(m,n))/ Zip two vectors with the given function.
    --
    -- @since 0.13.2.0
    zipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c
    {-# INLINE zipWith #-}
    zipWith :: forall a b c. (a -> b -> c) -> Vector a -> Vector b -> Vector c
    zipWith = (a -> b -> c) -> Vector a -> Vector b -> Vector c
    forall (v :: * -> *) a b c.
    (Vector v a, Vector v b, Vector v c) =>
    (a -> b -> c) -> v a -> v b -> v c
    G.zipWith

    -- | Zip three vectors with the given function.
    --
    -- @since 0.13.2.0
    zipWith3 :: (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
    {-# INLINE zipWith3 #-}
    zipWith3 :: forall a b c d.
    (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
    zipWith3 = (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
    forall (v :: * -> *) a b c d.
    (Vector v a, Vector v b, Vector v c, Vector v d) =>
    (a -> b -> c -> d) -> v a -> v b -> v c -> v d
    G.zipWith3

    zipWith4 :: (a -> b -> c -> d -> e)
             -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
    {-# INLINE zipWith4 #-}
    zipWith4 :: forall a b c d e.
    (a -> b -> c -> d -> e)
    -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
    zipWith4 = (a -> b -> c -> d -> e)
    -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
    forall (v :: * -> *) a b c d e.
    (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) =>
    (a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
    G.zipWith4

    zipWith5 :: (a -> b -> c -> d -> e -> f)
             -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
             -> Vector f
    {-# INLINE zipWith5 #-}
    zipWith5 :: forall a b c d e f.
    (a -> b -> c -> d -> e -> f)
    -> Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector f
    zipWith5 = (a -> b -> c -> d -> e -> f)
    -> Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector f
    forall (v :: * -> *) a b c d e f.
    (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
     Vector v f) =>
    (a -> b -> c -> d -> e -> f)
    -> v a -> v b -> v c -> v d -> v e -> v f
    G.zipWith5

    zipWith6 :: (a -> b -> c -> d -> e -> f -> g)
             -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
             -> Vector f -> Vector g
    {-# INLINE zipWith6 #-}
    zipWith6 :: forall a b c d e f g.
    (a -> b -> c -> d -> e -> f -> g)
    -> Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector f
    -> Vector g
    zipWith6 = (a -> b -> c -> d -> e -> f -> g)
    -> Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector f
    -> Vector g
    forall (v :: * -> *) a b c d e f g.
    (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)
    -> v a -> v b -> v c -> v d -> v e -> v f -> v g
    G.zipWith6

    -- | /O(min(m,n))/ Zip two vectors with a function that also takes the
    -- elements' indices.
    --
    -- @since 0.13.2.0
    izipWith :: (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
    {-# INLINE izipWith #-}
    izipWith :: forall a b c.
    (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
    izipWith = (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
    forall (v :: * -> *) a b c.
    (Vector v a, Vector v b, Vector v c) =>
    (Int -> a -> b -> c) -> v a -> v b -> v c
    G.izipWith

    -- | Zip three vectors and their indices with the given function.
    --
    -- @since 0.13.2.0
    izipWith3 :: (Int -> a -> b -> c -> d)
              -> Vector a -> Vector b -> Vector c -> Vector d
    {-# INLINE izipWith3 #-}
    izipWith3 :: forall a b c d.
    (Int -> a -> b -> c -> d)
    -> Vector a -> Vector b -> Vector c -> Vector d
    izipWith3 = (Int -> a -> b -> c -> d)
    -> Vector a -> Vector b -> Vector c -> Vector d
    forall (v :: * -> *) a b c d.
    (Vector v a, Vector v b, Vector v c, Vector v d) =>
    (Int -> a -> b -> c -> d) -> v a -> v b -> v c -> v d
    G.izipWith3

    izipWith4 :: (Int -> a -> b -> c -> d -> e)
              -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
    {-# INLINE izipWith4 #-}
    izipWith4 :: forall a b c d e.
    (Int -> a -> b -> c -> d -> e)
    -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
    izipWith4 = (Int -> a -> b -> c -> d -> e)
    -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
    forall (v :: * -> *) a b c d e.
    (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) =>
    (Int -> a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
    G.izipWith4

    izipWith5 :: (Int -> a -> b -> c -> d -> e -> f)
              -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
              -> Vector f
    {-# INLINE izipWith5 #-}
    izipWith5 :: forall a b c d e f.
    (Int -> a -> b -> c -> d -> e -> f)
    -> Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector f
    izipWith5 = (Int -> a -> b -> c -> d -> e -> f)
    -> Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector f
    forall (v :: * -> *) a b c d e f.
    (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
     Vector v f) =>
    (Int -> a -> b -> c -> d -> e -> f)
    -> v a -> v b -> v c -> v d -> v e -> v f
    G.izipWith5

    izipWith6 :: (Int -> a -> b -> c -> d -> e -> f -> g)
              -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
              -> Vector f -> Vector g
    {-# INLINE izipWith6 #-}
    izipWith6 :: forall a b c d e f g.
    (Int -> a -> b -> c -> d -> e -> f -> g)
    -> Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector f
    -> Vector g
    izipWith6 = (Int -> a -> b -> c -> d -> e -> f -> g)
    -> Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector f
    -> Vector g
    forall (v :: * -> *) a b c d e f g.
    (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
     Vector v f, Vector v g) =>
    (Int -> a -> b -> c -> d -> e -> f -> g)
    -> v a -> v b -> v c -> v d -> v e -> v f -> v g
    G.izipWith6

    -- | /O(min(m,n))/ Zip two vectors.
    --
    -- @since 0.13.2.0
    zip :: Vector a -> Vector b -> Vector (a, b)
    {-# INLINE zip #-}
    zip :: forall a b. Vector a -> Vector b -> Vector (a, b)
    zip = Vector a -> Vector b -> Vector (a, b)
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b, Vector v (a, b)) =>
    v a -> v b -> v (a, b)
    G.zip

    -- | Zip together three vectors into a vector of triples.
    --
    -- @since 0.13.2.0
    zip3 :: Vector a -> Vector b -> Vector c -> Vector (a, b, c)
    {-# INLINE zip3 #-}
    zip3 :: forall a b c. Vector a -> Vector b -> Vector c -> Vector (a, b, c)
    zip3 = Vector a -> Vector b -> Vector c -> Vector (a, b, c)
    forall (v :: * -> *) a b c.
    (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) =>
    v a -> v b -> v c -> v (a, b, c)
    G.zip3

    zip4 :: Vector a -> Vector b -> Vector c -> Vector d
         -> Vector (a, b, c, d)
    {-# INLINE zip4 #-}
    zip4 :: forall a b c d.
    Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)
    zip4 = Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)
    forall (v :: * -> *) a b c d.
    (Vector v a, Vector v b, Vector v c, Vector v d,
     Vector v (a, b, c, d)) =>
    v a -> v b -> v c -> v d -> v (a, b, c, d)
    G.zip4

    zip5 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector e
         -> Vector (a, b, c, d, e)
    {-# INLINE zip5 #-}
    zip5 :: forall a b c d e.
    Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector (a, b, c, d, e)
    zip5 = Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector (a, b, c, d, e)
    forall (v :: * -> *) a b c d e.
    (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
     Vector v (a, b, c, d, e)) =>
    v a -> v b -> v c -> v d -> v e -> v (a, b, c, d, e)
    G.zip5

    zip6 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
         -> Vector (a, b, c, d, e, f)
    {-# INLINE zip6 #-}
    zip6 :: forall a b c d e f.
    Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector f
    -> Vector (a, b, c, d, e, f)
    zip6 = Vector a
    -> Vector b
    -> Vector c
    -> Vector d
    -> Vector e
    -> Vector f
    -> Vector (a, b, c, d, e, f)
    forall (v :: * -> *) a b c d e f.
    (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)) =>
    v a -> v b -> v c -> v d -> v e -> v f -> v (a, b, c, d, e, f)
    G.zip6

    -- Unzipping
    -- ---------

    -- | /O(min(m,n))/ Unzip a vector of pairs.
    --
    -- @since 0.13.2.0
    unzip :: Vector (a, b) -> (Vector a, Vector b)
    {-# INLINE unzip #-}
    unzip :: forall a b. Vector (a, b) -> (Vector a, Vector b)
    unzip = Vector (a, b) -> (Vector a, Vector b)
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b, Vector v (a, b)) =>
    v (a, b) -> (v a, v b)
    G.unzip

    unzip3 :: Vector (a, b, c) -> (Vector a, Vector b, Vector c)
    {-# INLINE unzip3 #-}
    unzip3 :: forall a b c. Vector (a, b, c) -> (Vector a, Vector b, Vector c)
    unzip3 = Vector (a, b, c) -> (Vector a, Vector b, Vector c)
    forall (v :: * -> *) a b c.
    (Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) =>
    v (a, b, c) -> (v a, v b, v c)
    G.unzip3

    unzip4 :: Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)
    {-# INLINE unzip4 #-}
    unzip4 :: forall a b c d.
    Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)
    unzip4 = Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)
    forall (v :: * -> *) a b c d.
    (Vector v a, Vector v b, Vector v c, Vector v d,
     Vector v (a, b, c, d)) =>
    v (a, b, c, d) -> (v a, v b, v c, v d)
    G.unzip4

    unzip5 :: Vector (a, b, c, d, e)
           -> (Vector a, Vector b, Vector c, Vector d, Vector e)
    {-# INLINE unzip5 #-}
    unzip5 :: forall a b c d e.
    Vector (a, b, c, d, e)
    -> (Vector a, Vector b, Vector c, Vector d, Vector e)
    unzip5 = Vector (a, b, c, d, e)
    -> (Vector a, Vector b, Vector c, Vector d, Vector e)
    forall (v :: * -> *) a b c d e.
    (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
     Vector v (a, b, c, d, e)) =>
    v (a, b, c, d, e) -> (v a, v b, v c, v d, v e)
    G.unzip5

    unzip6 :: Vector (a, b, c, d, e, f)
           -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
    {-# INLINE unzip6 #-}
    unzip6 :: forall a b c d e f.
    Vector (a, b, c, d, e, f)
    -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
    unzip6 = Vector (a, b, c, d, e, f)
    -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
    forall (v :: * -> *) a b c d e f.
    (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)) =>
    v (a, b, c, d, e, f) -> (v a, v b, v c, v d, v e, v f)
    G.unzip6

    -- Monadic zipping
    -- ---------------

    -- | /O(min(m,n))/ Zip the two vectors with the monadic action and yield a
    -- vector of results.
    --
    -- @since 0.13.2.0
    zipWithM :: Monad m => (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
    {-# INLINE zipWithM #-}
    zipWithM :: forall (m :: * -> *) a b c.
    Monad m =>
    (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
    zipWithM = (a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
    forall (m :: * -> *) (v :: * -> *) a b c.
    (Monad m, Vector v a, Vector v b, Vector v c) =>
    (a -> b -> m c) -> v a -> v b -> m (v c)
    G.zipWithM

    -- | /O(min(m,n))/ Zip the two vectors with a monadic action that also takes
    -- the element index and yield a vector of results.
    --
    -- @since 0.13.2.0
    izipWithM :: Monad m => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
    {-# INLINE izipWithM #-}
    izipWithM :: forall (m :: * -> *) a b c.
    Monad m =>
    (Int -> a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
    izipWithM = (Int -> a -> b -> m c) -> Vector a -> Vector b -> m (Vector c)
    forall (m :: * -> *) (v :: * -> *) a b c.
    (Monad m, Vector v a, Vector v b, Vector v c) =>
    (Int -> a -> b -> m c) -> v a -> v b -> m (v c)
    G.izipWithM

    -- | /O(min(m,n))/ Zip the two vectors with the monadic action and ignore the
    -- results.
    --
    -- @since 0.13.2.0
    zipWithM_ :: Monad m => (a -> b -> m c) -> Vector a -> Vector b -> m ()
    {-# INLINE zipWithM_ #-}
    zipWithM_ :: forall (m :: * -> *) a b c.
    Monad m =>
    (a -> b -> m c) -> Vector a -> Vector b -> m ()
    zipWithM_ = (a -> b -> m c) -> Vector a -> Vector b -> m ()
    forall (m :: * -> *) (v :: * -> *) a b c.
    (Monad m, Vector v a, Vector v b) =>
    (a -> b -> m c) -> v a -> v b -> m ()
    G.zipWithM_

    -- | /O(min(m,n))/ Zip the two vectors with a monadic action that also takes
    -- the element index and ignore the results.
    --
    -- @since 0.13.2.0
    izipWithM_ :: Monad m => (Int -> a -> b -> m c) -> Vector a -> Vector b -> m ()
    {-# INLINE izipWithM_ #-}
    izipWithM_ :: forall (m :: * -> *) a b c.
    Monad m =>
    (Int -> a -> b -> m c) -> Vector a -> Vector b -> m ()
    izipWithM_ = (Int -> a -> b -> m c) -> Vector a -> Vector b -> m ()
    forall (m :: * -> *) (v :: * -> *) a b c.
    (Monad m, Vector v a, Vector v b) =>
    (Int -> a -> b -> m c) -> v a -> v b -> m ()
    G.izipWithM_

    -- Filtering
    -- ---------

    -- | /O(n)/ Drop all elements that do not satisfy the predicate.
    --
    -- @since 0.13.2.0
    filter :: (a -> Bool) -> Vector a -> Vector a
    {-# INLINE filter #-}
    filter :: forall a. (a -> Bool) -> Vector a -> Vector a
    filter = (a -> Bool) -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> v a
    G.filter

    -- | /O(n)/ Drop all elements that do not satisfy the predicate which is applied to
    -- the values and their indices.
    --
    -- @since 0.13.2.0
    ifilter :: (Int -> a -> Bool) -> Vector a -> Vector a
    {-# INLINE ifilter #-}
    ifilter :: forall a. (Int -> a -> Bool) -> Vector a -> Vector a
    ifilter = (Int -> a -> Bool) -> Vector a -> Vector a
    forall (v :: * -> *) a.
    Vector v a =>
    (Int -> a -> Bool) -> v a -> v a
    G.ifilter

    -- | /O(n)/ Drop repeated adjacent elements. The first element in each group is returned.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.uniq $ V.fromList [1,3,3,200,3]
    -- [1,3,200,3]
    -- >>> import Data.Semigroup
    -- >>> V.uniq $ V.fromList [ Arg 1 'a', Arg 1 'b', Arg 1 'c']
    -- [Arg 1 'a']
    --
    -- @since 0.13.2.0
    uniq :: (Eq a) => Vector a -> Vector a
    {-# INLINE uniq #-}
    uniq :: forall a. Eq a => Vector a -> Vector a
    uniq = Vector a -> Vector a
    forall (v :: * -> *) a. (Vector v a, Eq a) => v a -> v a
    G.uniq

    -- | /O(n)/ Map the values and collect the 'Just' results.
    --
    -- @since 0.13.2.0
    mapMaybe :: (a -> Maybe b) -> Vector a -> Vector b
    {-# INLINE mapMaybe #-}
    mapMaybe :: forall a b. (a -> Maybe b) -> Vector a -> Vector b
    mapMaybe = (a -> Maybe b) -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> Maybe b) -> v a -> v b
    G.mapMaybe

    -- | /O(n)/ Map the indices/values and collect the 'Just' results.
    --
    -- @since 0.13.2.0
    imapMaybe :: (Int -> a -> Maybe b) -> Vector a -> Vector b
    {-# INLINE imapMaybe #-}
    imapMaybe :: forall a b. (Int -> a -> Maybe b) -> Vector a -> Vector b
    imapMaybe = (Int -> a -> Maybe b) -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> Maybe b) -> v a -> v b
    G.imapMaybe

    -- | /O(n)/ Return a Vector of all the 'Just' values.
    --
    -- @since 0.13.2.0
    catMaybes :: Vector (Maybe a) -> Vector a
    {-# INLINE catMaybes #-}
    catMaybes :: forall a. Vector (Maybe a) -> Vector a
    catMaybes = (Maybe a -> Maybe a) -> Vector (Maybe a) -> Vector a
    forall a b. (a -> Maybe b) -> Vector a -> Vector b
    mapMaybe Maybe a -> Maybe a
    forall a. a -> a
    id

    -- | /O(n)/ Drop all elements that do not satisfy the monadic predicate.
    --
    -- @since 0.13.2.0
    filterM :: Monad m => (a -> m Bool) -> Vector a -> m (Vector a)
    {-# INLINE filterM #-}
    filterM :: forall (m :: * -> *) a.
    Monad m =>
    (a -> m Bool) -> Vector a -> m (Vector a)
    filterM = (a -> m Bool) -> Vector a -> m (Vector a)
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    (a -> m Bool) -> v a -> m (v a)
    G.filterM

    -- | /O(n)/ Apply the monadic function to each element of the vector and
    -- discard elements returning 'Nothing'.
    --
    -- @since 0.13.2.0
    mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Vector a -> m (Vector b)
    {-# INLINE mapMaybeM #-}
    mapMaybeM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m (Maybe b)) -> Vector a -> m (Vector b)
    mapMaybeM = (a -> m (Maybe b)) -> Vector a -> m (Vector b)
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a, Vector v b) =>
    (a -> m (Maybe b)) -> v a -> m (v b)
    G.mapMaybeM

    -- | /O(n)/ Apply the monadic function to each element of the vector and its index.
    -- Discard elements returning 'Nothing'.
    --
    -- @since 0.13.2.0
    imapMaybeM :: Monad m => (Int -> a -> m (Maybe b)) -> Vector a -> m (Vector b)
    {-# INLINE imapMaybeM #-}
    imapMaybeM :: forall (m :: * -> *) a b.
    Monad m =>
    (Int -> a -> m (Maybe b)) -> Vector a -> m (Vector b)
    imapMaybeM = (Int -> a -> m (Maybe b)) -> Vector a -> m (Vector b)
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a, Vector v b) =>
    (Int -> a -> m (Maybe b)) -> v a -> m (v b)
    G.imapMaybeM

    -- | /O(n)/ Yield the longest prefix of elements satisfying the predicate.
    -- The current implementation is not copy-free, unless the result vector is
    -- fused away.
    --
    -- @since 0.13.2.0
    takeWhile :: (a -> Bool) -> Vector a -> Vector a
    {-# INLINE takeWhile #-}
    takeWhile :: forall a. (a -> Bool) -> Vector a -> Vector a
    takeWhile = (a -> Bool) -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> v a
    G.takeWhile

    -- | /O(n)/ Drop the longest prefix of elements that satisfy the predicate
    -- without copying.
    --
    -- @since 0.13.2.0
    dropWhile :: (a -> Bool) -> Vector a -> Vector a
    {-# INLINE dropWhile #-}
    dropWhile :: forall a. (a -> Bool) -> Vector a -> Vector a
    dropWhile = (a -> Bool) -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> v a
    G.dropWhile

    -- Parititioning
    -- -------------

    -- | /O(n)/ Split the 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'.
    --
    -- @since 0.13.2.0
    partition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
    {-# INLINE partition #-}
    partition :: forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
    partition = (a -> Bool) -> Vector a -> (Vector a, Vector a)
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    G.partition

    -- | /O(n)/ Split the vector into two parts, the first one containing the
    -- @`Left`@ elements and the second containing the @`Right`@ elements.
    -- The relative order of the elements is preserved.
    --
    -- @since 0.13.2.0
    partitionWith :: (a -> Either b c) -> Vector a -> (Vector b, Vector c)
    {-# INLINE partitionWith #-}
    partitionWith :: forall a b c. (a -> Either b c) -> Vector a -> (Vector b, Vector c)
    partitionWith = (a -> Either b c) -> Vector a -> (Vector b, Vector c)
    forall (v :: * -> *) a b c.
    (Vector v a, Vector v b, Vector v c) =>
    (a -> Either b c) -> v a -> (v b, v c)
    G.partitionWith

    -- | /O(n)/ Split the 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'.
    --
    -- @since 0.13.2.0
    unstablePartition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
    {-# INLINE unstablePartition #-}
    unstablePartition :: forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
    unstablePartition = (a -> Bool) -> Vector a -> (Vector a, Vector a)
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    G.unstablePartition

    -- | /O(n)/ Split the vector into the longest prefix of elements that satisfy
    -- the predicate and the rest without copying.
    --
    -- Does not fuse.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.span (<4) $ V.generate 10 id
    -- ([0,1,2,3],[4,5,6,7,8,9])
    --
    -- @since 0.13.2.0
    span :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
    {-# INLINE span #-}
    span :: forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
    span = (a -> Bool) -> Vector a -> (Vector a, Vector a)
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    G.span

    -- | /O(n)/ Split the vector into the longest prefix of elements that do not
    -- satisfy the predicate and the rest without copying.
    --
    -- Does not fuse.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.break (>4) $ V.generate 10 id
    -- ([0,1,2,3,4],[5,6,7,8,9])
    --
    -- @since 0.13.2.0
    break :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
    {-# INLINE break #-}
    break :: forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
    break = (a -> Bool) -> Vector a -> (Vector a, Vector a)
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    G.break

    -- | /O(n)/ Split the vector into the longest prefix of elements that satisfy
    -- the predicate and the rest without copying.
    --
    -- Does not fuse.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.spanR (>4) $ V.generate 10 id
    -- ([5,6,7,8,9],[0,1,2,3,4])
    --
    -- @since 0.13.2.0
    spanR :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
    {-# INLINE spanR #-}
    spanR :: forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
    spanR = (a -> Bool) -> Vector a -> (Vector a, Vector a)
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    G.spanR

    -- | /O(n)/ Split the vector into the longest prefix of elements that do not
    -- satisfy the predicate and the rest without copying.
    --
    -- Does not fuse.
    --
    -- @since 0.13.2.0
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.breakR (<5) $ V.generate 10 id
    -- ([5,6,7,8,9],[0,1,2,3,4])
    --
    -- @since 0.13.2.0
    breakR :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
    {-# INLINE breakR #-}
    breakR :: forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
    breakR = (a -> Bool) -> Vector a -> (Vector a, Vector a)
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    G.breakR

    -- | /O(n)/ Split a vector into a list of slices, using a predicate function.
    --
    -- The concatenation of this list of slices is equal to the argument vector,
    -- and each slice contains only equal elements, as determined by the equality
    -- predicate function.
    --
    -- Does not fuse.
    --
    -- >>> import qualified Data.Vector as V
    -- >>> import           Data.Char (isUpper)
    -- >>> V.groupBy (\a b -> isUpper a == isUpper b) (V.fromList "Mississippi River")
    -- ["M","ississippi ","R","iver"]
    --
    -- See also 'Data.List.groupBy', 'group'.
    --
    -- @since 0.13.2.0
    groupBy :: (a -> a -> Bool) -> Vector a -> [Vector a]
    {-# INLINE groupBy #-}
    groupBy :: forall a. (a -> a -> Bool) -> Vector a -> [Vector a]
    groupBy = (a -> a -> Bool) -> Vector a -> [Vector a]
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Bool) -> v a -> [v a]
    G.groupBy

    -- | /O(n)/ Split a vector into a list of slices of the input vector.
    --
    -- The concatenation of this list of slices is equal to the argument vector,
    -- and each slice contains only equal elements.
    --
    -- Does not fuse.
    --
    -- This is the equivalent of 'groupBy (==)'.
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.group (V.fromList "Mississippi")
    -- ["M","i","ss","i","ss","i","pp","i"]
    --
    -- See also 'Data.List.group'.
    --
    -- @since 0.13.2.0
    group :: Eq a => Vector a -> [Vector a]
    {-# INLINE group #-}
    group :: forall a. Eq a => Vector a -> [Vector a]
    group = (a -> a -> Bool) -> Vector a -> [Vector a]
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Bool) -> v a -> [v a]
    G.groupBy a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    (==)

    -- Searching
    -- ---------

    infix 4 `elem`
    -- | /O(n)/ Check if the vector contains an element.
    --
    -- @since 0.13.2.0
    elem :: Eq a => a -> Vector a -> Bool
    {-# INLINE elem #-}
    elem :: forall a. Eq a => a -> Vector a -> Bool
    elem = a -> Vector a -> Bool
    forall (v :: * -> *) a. (Vector v a, Eq a) => a -> v a -> Bool
    G.elem

    infix 4 `notElem`
    -- | /O(n)/ Check if the vector does not contain an element (inverse of 'elem').
    --
    -- @since 0.13.2.0
    notElem :: Eq a => a -> Vector a -> Bool
    {-# INLINE notElem #-}
    notElem :: forall a. Eq a => a -> Vector a -> Bool
    notElem = a -> Vector a -> Bool
    forall (v :: * -> *) a. (Vector v a, Eq a) => a -> v a -> Bool
    G.notElem

    -- | /O(n)/ Yield 'Just' the first element matching the predicate or 'Nothing'
    -- if no such element exists.
    --
    -- @since 0.13.2.0
    find :: (a -> Bool) -> Vector a -> Maybe a
    {-# INLINE find #-}
    find :: forall a. (a -> Bool) -> Vector a -> Maybe a
    find = (a -> Bool) -> Vector a -> Maybe a
    forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> Maybe a
    G.find

    -- | /O(n)/ Yield 'Just' the index of the first element matching the predicate
    -- or 'Nothing' if no such element exists.
    --
    -- @since 0.13.2.0
    findIndex :: (a -> Bool) -> Vector a -> Maybe Int
    {-# INLINE findIndex #-}
    findIndex :: forall a. (a -> Bool) -> Vector a -> Maybe Int
    findIndex = (a -> Bool) -> Vector a -> Maybe Int
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> Maybe Int
    G.findIndex

    -- | /O(n)/ Yield 'Just' the index of the /last/ element matching the predicate
    -- or 'Nothing' if no such element exists.
    --
    -- Does not fuse.
    --
    -- @since 0.13.2.0
    findIndexR :: (a -> Bool) -> Vector a -> Maybe Int
    {-# INLINE findIndexR #-}
    findIndexR :: forall a. (a -> Bool) -> Vector a -> Maybe Int
    findIndexR = (a -> Bool) -> Vector a -> Maybe Int
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> Maybe Int
    G.findIndexR

    -- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending
    -- order.
    --
    -- @since 0.13.2.0
    findIndices :: (a -> Bool) -> Vector a -> Vector Int
    {-# INLINE findIndices #-}
    findIndices :: forall a. (a -> Bool) -> Vector a -> Vector Int
    findIndices = (a -> Bool) -> Vector a -> Vector Int
    forall (v :: * -> *) a.
    (Vector v a, Vector v Int) =>
    (a -> Bool) -> v a -> v Int
    G.findIndices

    -- | /O(n)/ Yield 'Just' the index of the first occurrence of the given element or
    -- 'Nothing' if the vector does not contain the element. This is a specialised
    -- version of 'findIndex'.
    --
    -- @since 0.13.2.0
    elemIndex :: Eq a => a -> Vector a -> Maybe Int
    {-# INLINE elemIndex #-}
    elemIndex :: forall a. Eq a => a -> Vector a -> Maybe Int
    elemIndex = a -> Vector a -> Maybe Int
    forall (v :: * -> *) a. (Vector v a, Eq a) => a -> v a -> Maybe Int
    G.elemIndex

    -- | /O(n)/ Yield the indices of all occurrences of the given element in
    -- ascending order. This is a specialised version of 'findIndices'.
    --
    -- @since 0.13.2.0
    elemIndices :: Eq a => a -> Vector a -> Vector Int
    {-# INLINE elemIndices #-}
    elemIndices :: forall a. Eq a => a -> Vector a -> Vector Int
    elemIndices = a -> Vector a -> Vector Int
    forall (v :: * -> *) a.
    (Vector v a, Vector v Int, Eq a) =>
    a -> v a -> v Int
    G.elemIndices

    -- Folding
    -- -------

    -- | /O(n)/ Left fold.
    --
    -- @since 0.13.2.0
    foldl :: (a -> b -> a) -> a -> Vector b -> a
    {-# INLINE foldl #-}
    foldl :: forall b a. (b -> a -> b) -> b -> Vector a -> b
    foldl = (a -> b -> a) -> a -> Vector b -> a
    forall (v :: * -> *) b a.
    Vector v b =>
    (a -> b -> a) -> a -> v b -> a
    G.foldl

    -- | /O(n)/ Left fold on non-empty vectors.
    --
    -- @since 0.13.2.0
    foldl1 :: (a -> a -> a) -> Vector a -> a
    {-# INLINE foldl1 #-}
    foldl1 :: forall a. (a -> a -> a) -> Vector a -> a
    foldl1 = (a -> a -> a) -> Vector a -> a
    forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
    G.foldl1

    -- | /O(n)/ Left fold with strict accumulator.
    --
    -- @since 0.13.2.0
    foldl' :: (a -> b -> a) -> a -> Vector b -> a
    {-# INLINE foldl' #-}
    foldl' :: forall b a. (b -> a -> b) -> b -> Vector a -> b
    foldl' = (a -> b -> a) -> a -> Vector b -> a
    forall (v :: * -> *) b a.
    Vector v b =>
    (a -> b -> a) -> a -> v b -> a
    G.foldl'

    -- | /O(n)/ Left fold on non-empty vectors with strict accumulator.
    --
    -- @since 0.13.2.0
    foldl1' :: (a -> a -> a) -> Vector a -> a
    {-# INLINE foldl1' #-}
    foldl1' :: forall a. (a -> a -> a) -> Vector a -> a
    foldl1' = (a -> a -> a) -> Vector a -> a
    forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
    G.foldl1'

    -- | /O(n)/ Right fold.
    --
    -- @since 0.13.2.0
    foldr :: (a -> b -> b) -> b -> Vector a -> b
    {-# INLINE foldr #-}
    foldr :: forall a b. (a -> b -> b) -> b -> Vector a -> b
    foldr = (a -> b -> b) -> b -> Vector a -> b
    forall (v :: * -> *) a b.
    Vector v a =>
    (a -> b -> b) -> b -> v a -> b
    G.foldr

    -- | /O(n)/ Right fold on non-empty vectors.
    --
    -- @since 0.13.2.0
    foldr1 :: (a -> a -> a) -> Vector a -> a
    {-# INLINE foldr1 #-}
    foldr1 :: forall a. (a -> a -> a) -> Vector a -> a
    foldr1 = (a -> a -> a) -> Vector a -> a
    forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
    G.foldr1

    -- | /O(n)/ Right fold with a strict accumulator.
    --
    -- @since 0.13.2.0
    foldr' :: (a -> b -> b) -> b -> Vector a -> b
    {-# INLINE foldr' #-}
    foldr' :: forall a b. (a -> b -> b) -> b -> Vector a -> b
    foldr' = (a -> b -> b) -> b -> Vector a -> b
    forall (v :: * -> *) a b.
    Vector v a =>
    (a -> b -> b) -> b -> v a -> b
    G.foldr'

    -- | /O(n)/ Right fold on non-empty vectors with strict accumulator.
    --
    -- @since 0.13.2.0
    foldr1' :: (a -> a -> a) -> Vector a -> a
    {-# INLINE foldr1' #-}
    foldr1' :: forall a. (a -> a -> a) -> Vector a -> a
    foldr1' = (a -> a -> a) -> Vector a -> a
    forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
    G.foldr1'

    -- | /O(n)/ Left fold using a function applied to each element and its index.
    --
    -- @since 0.13.2.0
    ifoldl :: (a -> Int -> b -> a) -> a -> Vector b -> a
    {-# INLINE ifoldl #-}
    ifoldl :: forall a b. (a -> Int -> b -> a) -> a -> Vector b -> a
    ifoldl = (a -> Int -> b -> a) -> a -> Vector b -> a
    forall (v :: * -> *) b a.
    Vector v b =>
    (a -> Int -> b -> a) -> a -> v b -> a
    G.ifoldl

    -- | /O(n)/ Left fold with strict accumulator using a function applied to each element
    -- and its index.
    --
    -- @since 0.13.2.0
    ifoldl' :: (a -> Int -> b -> a) -> a -> Vector b -> a
    {-# INLINE ifoldl' #-}
    ifoldl' :: forall a b. (a -> Int -> b -> a) -> a -> Vector b -> a
    ifoldl' = (a -> Int -> b -> a) -> a -> Vector b -> a
    forall (v :: * -> *) b a.
    Vector v b =>
    (a -> Int -> b -> a) -> a -> v b -> a
    G.ifoldl'

    -- | /O(n)/ Right fold using a function applied to each element and its index.
    --
    -- @since 0.13.2.0
    ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b
    {-# INLINE ifoldr #-}
    ifoldr :: forall a b. (Int -> a -> b -> b) -> b -> Vector a -> b
    ifoldr = (Int -> a -> b -> b) -> b -> Vector a -> b
    forall (v :: * -> *) a b.
    Vector v a =>
    (Int -> a -> b -> b) -> b -> v a -> b
    G.ifoldr

    -- | /O(n)/ Right fold with strict accumulator using a function applied to each
    -- element and its index.
    --
    -- @since 0.13.2.0
    ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b
    {-# INLINE ifoldr' #-}
    ifoldr' :: forall a b. (Int -> a -> b -> b) -> b -> Vector a -> b
    ifoldr' = (Int -> a -> b -> b) -> b -> Vector a -> b
    forall (v :: * -> *) a b.
    Vector v a =>
    (Int -> a -> b -> b) -> b -> v a -> b
    G.ifoldr'

    -- | /O(n)/ Map each element of the structure to a monoid and combine
    -- the results. It uses the same implementation as the corresponding method
    -- of the 'Foldable' type class. Note that it's implemented in terms of 'foldr'
    -- and won't fuse with functions that traverse the vector from left to
    -- right ('map', 'generate', etc.).
    --
    -- @since 0.13.2.0
    foldMap :: (Monoid m) => (a -> m) -> Vector a -> m
    {-# INLINE foldMap #-}
    foldMap :: forall m a. Monoid m => (a -> m) -> Vector a -> m
    foldMap = (a -> m) -> Vector a -> m
    forall m (v :: * -> *) a.
    (Monoid m, Vector v a) =>
    (a -> m) -> v a -> m
    G.foldMap

    -- | /O(n)/ Like 'foldMap', but strict in the accumulator. It uses the same
    -- implementation as the corresponding method of the 'Foldable' type class.
    -- Note that it's implemented in terms of 'foldl'', so it fuses in most
    -- contexts.
    --
    -- @since 0.13.2.0
    foldMap' :: (Monoid m) => (a -> m) -> Vector a -> m
    {-# INLINE foldMap' #-}
    foldMap' :: forall m a. Monoid m => (a -> m) -> Vector a -> m
    foldMap' = (a -> m) -> Vector a -> m
    forall m (v :: * -> *) a.
    (Monoid m, Vector v a) =>
    (a -> m) -> v a -> m
    G.foldMap'

    -- Specialised folds
    -- -----------------

    -- | /O(n)/ Check if all elements satisfy the predicate.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.all even $ V.fromList [2, 4, 12]
    -- True
    -- >>> V.all even $ V.fromList [2, 4, 13]
    -- False
    -- >>> V.all even (V.empty :: V.Vector Int)
    -- True
    --
    -- @since 0.13.2.0
    all :: (a -> Bool) -> Vector a -> Bool
    {-# INLINE all #-}
    all :: forall a. (a -> Bool) -> Vector a -> Bool
    all = (a -> Bool) -> Vector a -> Bool
    forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> Bool
    G.all

    -- | /O(n)/ Check if any element satisfies the predicate.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.any even $ V.fromList [1, 3, 7]
    -- False
    -- >>> V.any even $ V.fromList [3, 2, 13]
    -- True
    -- >>> V.any even (V.empty :: V.Vector Int)
    -- False
    --
    -- @since 0.13.2.0
    any :: (a -> Bool) -> Vector a -> Bool
    {-# INLINE any #-}
    any :: forall a. (a -> Bool) -> Vector a -> Bool
    any = (a -> Bool) -> Vector a -> Bool
    forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> Bool
    G.any

    -- | /O(n)/ Check if all elements are 'True'.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.and $ V.fromList [True, False]
    -- False
    -- >>> V.and V.empty
    -- True
    --
    -- @since 0.13.2.0
    and :: Vector Bool -> Bool
    {-# INLINE and #-}
    and :: Vector Bool -> Bool
    and = Vector Bool -> Bool
    forall (v :: * -> *). Vector v Bool => v Bool -> Bool
    G.and

    -- | /O(n)/ Check if any element is 'True'.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.or $ V.fromList [True, False]
    -- True
    -- >>> V.or V.empty
    -- False
    --
    -- @since 0.13.2.0
    or :: Vector Bool -> Bool
    {-# INLINE or #-}
    or :: Vector Bool -> Bool
    or = Vector Bool -> Bool
    forall (v :: * -> *). Vector v Bool => v Bool -> Bool
    G.or

    -- | /O(n)/ Compute the sum of the elements.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.sum $ V.fromList [300,20,1]
    -- 321
    -- >>> V.sum (V.empty :: V.Vector Int)
    -- 0
    --
    -- @since 0.13.2.0
    sum :: Num a => Vector a -> a
    {-# INLINE sum #-}
    sum :: forall a. Num a => Vector a -> a
    sum = Vector a -> a
    forall (v :: * -> *) a. (Vector v a, Num a) => v a -> a
    G.sum

    -- | /O(n)/ Compute the product of the elements.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.product $ V.fromList [1,2,3,4]
    -- 24
    -- >>> V.product (V.empty :: V.Vector Int)
    -- 1
    --
    -- @since 0.13.2.0
    product :: Num a => Vector a -> a
    {-# INLINE product #-}
    product :: forall a. Num a => Vector a -> a
    product = Vector a -> a
    forall (v :: * -> *) a. (Vector v a, Num a) => v a -> a
    G.product

    -- | /O(n)/ Yield the maximum element of the vector. The vector may not be
    -- empty. In case of a tie, the first occurrence wins.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.maximum $ V.fromList [2, 1]
    -- 2
    -- >>> import Data.Semigroup
    -- >>> V.maximum $ V.fromList [Arg 1 'a', Arg 2 'b']
    -- Arg 2 'b'
    -- >>> V.maximum $ V.fromList [Arg 1 'a', Arg 1 'b']
    -- Arg 1 'a'
    --
    -- @since 0.13.2.0
    maximum :: Ord a => Vector a -> a
    {-# INLINE maximum #-}
    maximum :: forall a. Ord a => Vector a -> a
    maximum = Vector a -> a
    forall (v :: * -> *) a. (Vector v a, Ord a) => v a -> a
    G.maximum

    -- | /O(n)/ Yield the maximum element of the vector according to the
    -- given comparison function. The vector may not be empty. In case of
    -- a tie, the first occurrence wins. This behavior is different from
    -- 'Data.List.maximumBy' which returns the last tie.
    --
    -- ==== __Examples__
    --
    -- >>> import Data.Ord
    -- >>> import qualified Data.Vector as V
    -- >>> V.maximumBy (comparing fst) $ V.fromList [(2,'a'), (1,'b')]
    -- (2,'a')
    -- >>> V.maximumBy (comparing fst) $ V.fromList [(1,'a'), (1,'b')]
    -- (1,'a')
    --
    -- @since 0.13.2.0
    maximumBy :: (a -> a -> Ordering) -> Vector a -> a
    {-# INLINE maximumBy #-}
    maximumBy :: forall a. (a -> a -> Ordering) -> Vector a -> a
    maximumBy = (a -> a -> Ordering) -> Vector a -> a
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Ordering) -> v a -> a
    G.maximumBy

    -- | /O(n)/ Yield the maximum element of the vector by comparing the results
    -- of a key function on each element. In case of a tie, the first occurrence
    -- wins. The vector may not be empty.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.maximumOn fst $ V.fromList [(2,'a'), (1,'b')]
    -- (2,'a')
    -- >>> V.maximumOn fst $ V.fromList [(1,'a'), (1,'b')]
    -- (1,'a')
    --
    -- @since 0.13.2.0
    maximumOn :: Ord b => (a -> b) -> Vector a -> a
    {-# INLINE maximumOn #-}
    maximumOn :: forall b a. Ord b => (a -> b) -> Vector a -> a
    maximumOn = (a -> b) -> Vector a -> a
    forall b (v :: * -> *) a.
    (Ord b, Vector v a) =>
    (a -> b) -> v a -> a
    G.maximumOn

    -- | /O(n)/ Yield the minimum element of the vector. The vector may not be
    -- empty. In case of a tie, the first occurrence wins.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.minimum $ V.fromList [2, 1]
    -- 1
    -- >>> import Data.Semigroup
    -- >>> V.minimum $ V.fromList [Arg 2 'a', Arg 1 'b']
    -- Arg 1 'b'
    -- >>> V.minimum $ V.fromList [Arg 1 'a', Arg 1 'b']
    -- Arg 1 'a'
    --
    -- @since 0.13.2.0
    minimum :: Ord a => Vector a -> a
    {-# INLINE minimum #-}
    minimum :: forall a. Ord a => Vector a -> a
    minimum = Vector a -> a
    forall (v :: * -> *) a. (Vector v a, Ord a) => v a -> a
    G.minimum

    -- | /O(n)/ Yield the minimum element of the vector according to the
    -- given comparison function. The vector may not be empty. In case of
    -- a tie, the first occurrence wins.
    --
    -- ==== __Examples__
    --
    -- >>> import Data.Ord
    -- >>> import qualified Data.Vector as V
    -- >>> V.minimumBy (comparing fst) $ V.fromList [(2,'a'), (1,'b')]
    -- (1,'b')
    -- >>> V.minimumBy (comparing fst) $ V.fromList [(1,'a'), (1,'b')]
    -- (1,'a')
    --
    -- @since 0.13.2.0
    minimumBy :: (a -> a -> Ordering) -> Vector a -> a
    {-# INLINE minimumBy #-}
    minimumBy :: forall a. (a -> a -> Ordering) -> Vector a -> a
    minimumBy = (a -> a -> Ordering) -> Vector a -> a
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Ordering) -> v a -> a
    G.minimumBy

    -- | /O(n)/ Yield the minimum element of the vector by comparing the results
    -- of a key function on each element. In case of a tie, the first occurrence
    -- wins. The vector may not be empty.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.minimumOn fst $ V.fromList [(2,'a'), (1,'b')]
    -- (1,'b')
    -- >>> V.minimumOn fst $ V.fromList [(1,'a'), (1,'b')]
    -- (1,'a')
    --
    -- @since 0.13.2.0
    minimumOn :: Ord b => (a -> b) -> Vector a -> a
    {-# INLINE minimumOn #-}
    minimumOn :: forall b a. Ord b => (a -> b) -> Vector a -> a
    minimumOn = (a -> b) -> Vector a -> a
    forall b (v :: * -> *) a.
    (Ord b, Vector v a) =>
    (a -> b) -> v a -> a
    G.minimumOn

    -- | /O(n)/ Yield the index of the maximum element of the vector. The vector
    -- may not be empty.
    --
    -- @since 0.13.2.0
    maxIndex :: Ord a => Vector a -> Int
    {-# INLINE maxIndex #-}
    maxIndex :: forall a. Ord a => Vector a -> Int
    maxIndex = Vector a -> Int
    forall (v :: * -> *) a. (Vector v a, Ord a) => v a -> Int
    G.maxIndex

    -- | /O(n)/ Yield the index of the maximum element of the vector
    -- according to the given comparison function. The vector may not be
    -- empty. In case of a tie, the first occurrence wins.
    --
    -- ==== __Examples__
    --
    -- >>> import Data.Ord
    -- >>> import qualified Data.Vector as V
    -- >>> V.maxIndexBy (comparing fst) $ V.fromList [(2,'a'), (1,'b')]
    -- 0
    -- >>> V.maxIndexBy (comparing fst) $ V.fromList [(1,'a'), (1,'b')]
    -- 0
    --
    -- @since 0.13.2.0
    maxIndexBy :: (a -> a -> Ordering) -> Vector a -> Int
    {-# INLINE maxIndexBy #-}
    maxIndexBy :: forall a. (a -> a -> Ordering) -> Vector a -> Int
    maxIndexBy = (a -> a -> Ordering) -> Vector a -> Int
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Ordering) -> v a -> Int
    G.maxIndexBy

    -- | /O(n)/ Yield the index of the minimum element of the vector. The vector
    -- may not be empty.
    --
    -- @since 0.13.2.0
    minIndex :: Ord a => Vector a -> Int
    {-# INLINE minIndex #-}
    minIndex :: forall a. Ord a => Vector a -> Int
    minIndex = Vector a -> Int
    forall (v :: * -> *) a. (Vector v a, Ord a) => v a -> Int
    G.minIndex

    -- | /O(n)/ Yield the index of the minimum element of the vector according to
    -- the given comparison function. The vector may not be empty.
    --
    -- ==== __Examples__
    --
    -- >>> import Data.Ord
    -- >>> import qualified Data.Vector as V
    -- >>> V.minIndexBy (comparing fst) $ V.fromList [(2,'a'), (1,'b')]
    -- 1
    -- >>> V.minIndexBy (comparing fst) $ V.fromList [(1,'a'), (1,'b')]
    -- 0
    --
    -- @since 0.13.2.0
    minIndexBy :: (a -> a -> Ordering) -> Vector a -> Int
    {-# INLINE minIndexBy #-}
    minIndexBy :: forall a. (a -> a -> Ordering) -> Vector a -> Int
    minIndexBy = (a -> a -> Ordering) -> Vector a -> Int
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Ordering) -> v a -> Int
    G.minIndexBy

    -- Monadic folds
    -- -------------

    -- | /O(n)/ Monadic fold.
    --
    -- @since 0.13.2.0
    foldM :: Monad m => (a -> b -> m a) -> a -> Vector b -> m a
    {-# INLINE foldM #-}
    foldM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> m a) -> a -> Vector b -> m a
    foldM = (a -> b -> m a) -> a -> Vector b -> m a
    forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> b -> m a) -> a -> v b -> m a
    G.foldM

    -- | /O(n)/ Monadic fold using a function applied to each element and its index.
    --
    -- @since 0.13.2.0
    ifoldM :: Monad m => (a -> Int -> b -> m a) -> a -> Vector b -> m a
    {-# INLINE ifoldM #-}
    ifoldM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> Int -> b -> m a) -> a -> Vector b -> m a
    ifoldM = (a -> Int -> b -> m a) -> a -> Vector b -> m a
    forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> Int -> b -> m a) -> a -> v b -> m a
    G.ifoldM

    -- | /O(n)/ Monadic fold over non-empty vectors.
    --
    -- @since 0.13.2.0
    fold1M :: Monad m => (a -> a -> m a) -> Vector a -> m a
    {-# INLINE fold1M #-}
    fold1M :: forall (m :: * -> *) a.
    Monad m =>
    (a -> a -> m a) -> Vector a -> m a
    fold1M = (a -> a -> m a) -> Vector a -> m a
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    (a -> a -> m a) -> v a -> m a
    G.fold1M

    -- | /O(n)/ Monadic fold with strict accumulator.
    --
    -- @since 0.13.2.0
    foldM' :: Monad m => (a -> b -> m a) -> a -> Vector b -> m a
    {-# INLINE foldM' #-}
    foldM' :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> m a) -> a -> Vector b -> m a
    foldM' = (a -> b -> m a) -> a -> Vector b -> m a
    forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> b -> m a) -> a -> v b -> m a
    G.foldM'

    -- | /O(n)/ Monadic fold with strict accumulator using a function applied to each
    -- element and its index.
    --
    -- @since 0.13.2.0
    ifoldM' :: Monad m => (a -> Int -> b -> m a) -> a -> Vector b -> m a
    {-# INLINE ifoldM' #-}
    ifoldM' :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> Int -> b -> m a) -> a -> Vector b -> m a
    ifoldM' = (a -> Int -> b -> m a) -> a -> Vector b -> m a
    forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> Int -> b -> m a) -> a -> v b -> m a
    G.ifoldM'

    -- | /O(n)/ Monadic fold over non-empty vectors with strict accumulator.
    --
    -- @since 0.13.2.0
    fold1M' :: Monad m => (a -> a -> m a) -> Vector a -> m a
    {-# INLINE fold1M' #-}
    fold1M' :: forall (m :: * -> *) a.
    Monad m =>
    (a -> a -> m a) -> Vector a -> m a
    fold1M' = (a -> a -> m a) -> Vector a -> m a
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    (a -> a -> m a) -> v a -> m a
    G.fold1M'

    -- | /O(n)/ Monadic fold that discards the result.
    --
    -- @since 0.13.2.0
    foldM_ :: Monad m => (a -> b -> m a) -> a -> Vector b -> m ()
    {-# INLINE foldM_ #-}
    foldM_ :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> m a) -> a -> Vector b -> m ()
    foldM_ = (a -> b -> m a) -> a -> Vector b -> m ()
    forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> b -> m a) -> a -> v b -> m ()
    G.foldM_

    -- | /O(n)/ Monadic fold that discards the result using a function applied to
    -- each element and its index.
    --
    -- @since 0.13.2.0
    ifoldM_ :: Monad m => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
    {-# INLINE ifoldM_ #-}
    ifoldM_ :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> Int -> b -> m a) -> a -> Vector b -> m ()
    ifoldM_ = (a -> Int -> b -> m a) -> a -> Vector b -> m ()
    forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> Int -> b -> m a) -> a -> v b -> m ()
    G.ifoldM_

    -- | /O(n)/ Monadic fold over non-empty vectors that discards the result.
    --
    -- @since 0.13.2.0
    fold1M_ :: Monad m => (a -> a -> m a) -> Vector a -> m ()
    {-# INLINE fold1M_ #-}
    fold1M_ :: forall (m :: * -> *) a.
    Monad m =>
    (a -> a -> m a) -> Vector a -> m ()
    fold1M_ = (a -> a -> m a) -> Vector a -> m ()
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    (a -> a -> m a) -> v a -> m ()
    G.fold1M_

    -- | /O(n)/ Monadic fold with strict accumulator that discards the result.
    --
    -- @since 0.13.2.0
    foldM'_ :: Monad m => (a -> b -> m a) -> a -> Vector b -> m ()
    {-# INLINE foldM'_ #-}
    foldM'_ :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> m a) -> a -> Vector b -> m ()
    foldM'_ = (a -> b -> m a) -> a -> Vector b -> m ()
    forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> b -> m a) -> a -> v b -> m ()
    G.foldM'_

    -- | /O(n)/ Monadic fold with strict accumulator that discards the result
    -- using a function applied to each element and its index.
    --
    -- @since 0.13.2.0
    ifoldM'_ :: Monad m => (a -> Int -> b -> m a) -> a -> Vector b -> m ()
    {-# INLINE ifoldM'_ #-}
    ifoldM'_ :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> Int -> b -> m a) -> a -> Vector b -> m ()
    ifoldM'_ = (a -> Int -> b -> m a) -> a -> Vector b -> m ()
    forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> Int -> b -> m a) -> a -> v b -> m ()
    G.ifoldM'_

    -- | /O(n)/ Monadic fold over non-empty vectors with strict accumulator
    -- that discards the result.
    --
    -- @since 0.13.2.0
    fold1M'_ :: Monad m => (a -> a -> m a) -> Vector a -> m ()
    {-# INLINE fold1M'_ #-}
    fold1M'_ :: forall (m :: * -> *) a.
    Monad m =>
    (a -> a -> m a) -> Vector a -> m ()
    fold1M'_ = (a -> a -> m a) -> Vector a -> m ()
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    (a -> a -> m a) -> v a -> m ()
    G.fold1M'_

    -- Monadic sequencing
    -- ------------------

    -- | Evaluate each action and collect the results.
    --
    -- @since 0.13.2.0
    sequence :: Monad m => Vector (m a) -> m (Vector a)
    {-# INLINE sequence #-}
    sequence :: forall (m :: * -> *) a. Monad m => Vector (m a) -> m (Vector a)
    sequence = Vector (m a) -> m (Vector a)
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a, Vector v (m a)) =>
    v (m a) -> m (v a)
    G.sequence

    -- | Evaluate each action and discard the results.
    --
    -- @since 0.13.2.0
    sequence_ :: Monad m => Vector (m a) -> m ()
    {-# INLINE sequence_ #-}
    sequence_ :: forall (m :: * -> *) a. Monad m => Vector (m a) -> m ()
    sequence_ = Vector (m a) -> m ()
    forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v (m a)) =>
    v (m a) -> m ()
    G.sequence_

    -- Scans
    -- -----

    -- | /O(n)/ Left-to-right prescan.
    --
    -- @
    -- prescanl f z = 'init' . 'scanl' f z
    -- @
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.prescanl (+) 0 (V.fromList [1,2,3,4])
    -- [0,1,3,6]
    --
    -- @since 0.13.2.0
    prescanl :: (a -> b -> a) -> a -> Vector b -> Vector a
    {-# INLINE prescanl #-}
    prescanl :: forall a b. (a -> b -> a) -> a -> Vector b -> Vector a
    prescanl = (a -> b -> a) -> a -> Vector b -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    G.prescanl

    -- | /O(n)/ Left-to-right prescan with strict accumulator.
    --
    -- @since 0.13.2.0
    prescanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
    {-# INLINE prescanl' #-}
    prescanl' :: forall a b. (a -> b -> a) -> a -> Vector b -> Vector a
    prescanl' = (a -> b -> a) -> a -> Vector b -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    G.prescanl'

    -- | /O(n)/ Left-to-right postscan.
    --
    -- @
    -- postscanl f z = 'tail' . 'scanl' f z
    -- @
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.postscanl (+) 0 (V.fromList [1,2,3,4])
    -- [1,3,6,10]
    --
    -- @since 0.13.2.0
    postscanl :: (a -> b -> a) -> a -> Vector b -> Vector a
    {-# INLINE postscanl #-}
    postscanl :: forall a b. (a -> b -> a) -> a -> Vector b -> Vector a
    postscanl = (a -> b -> a) -> a -> Vector b -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    G.postscanl

    -- | /O(n)/ Left-to-right postscan with strict accumulator.
    --
    -- @since 0.13.2.0
    postscanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
    {-# INLINE postscanl' #-}
    postscanl' :: forall a b. (a -> b -> a) -> a -> Vector b -> Vector a
    postscanl' = (a -> b -> a) -> a -> Vector b -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    G.postscanl'

    -- | /O(n)/ Left-to-right scan.
    --
    -- > scanl f z <x1,...,xn> = <y1,...,y(n+1)>
    -- >   where y1 = z
    -- >         yi = f y(i-1) x(i-1)
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector as V
    -- >>> V.scanl (+) 0 (V.fromList [1,2,3,4])
    -- [0,1,3,6,10]
    --
    -- @since 0.13.2.0
    scanl :: (a -> b -> a) -> a -> Vector b -> Vector a
    {-# INLINE scanl #-}
    scanl :: forall a b. (a -> b -> a) -> a -> Vector b -> Vector a
    scanl = (a -> b -> a) -> a -> Vector b -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    G.scanl

    -- | /O(n)/ Left-to-right scan with strict accumulator.
    --
    -- @since 0.13.2.0
    scanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
    {-# INLINE scanl' #-}
    scanl' :: forall a b. (a -> b -> a) -> a -> Vector b -> Vector a
    scanl' = (a -> b -> a) -> a -> Vector b -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    G.scanl'

    -- | /O(n)/ Left-to-right scan over a vector with its index.
    --
    -- @since 0.13.2.0
    iscanl :: (Int -> a -> b -> a) -> a -> Vector b -> Vector a
    {-# INLINE iscanl #-}
    iscanl :: forall a b. (Int -> a -> b -> a) -> a -> Vector b -> Vector a
    iscanl = (Int -> a -> b -> a) -> a -> Vector b -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> b -> a) -> a -> v b -> v a
    G.iscanl

    -- | /O(n)/ Left-to-right scan over a vector (strictly) with its index.
    --
    -- @since 0.13.2.0
    iscanl' :: (Int -> a -> b -> a) -> a -> Vector b -> Vector a
    {-# INLINE iscanl' #-}
    iscanl' :: forall a b. (Int -> a -> b -> a) -> a -> Vector b -> Vector a
    iscanl' = (Int -> a -> b -> a) -> a -> Vector b -> Vector a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> b -> a) -> a -> v b -> v a
    G.iscanl'

    -- | /O(n)/ Initial-value free left-to-right scan over a vector.
    --
    -- > scanl f <x1,...,xn> = <y1,...,yn>
    -- >   where y1 = x1
    -- >         yi = f y(i-1) xi
    --
    -- Note: Since 0.13, application of this to an empty vector no longer
    -- results in an error; instead it produces an empty vector.
    --
    -- ==== __Examples__
    -- >>> import qualified Data.Vector as V
    -- >>> V.scanl1 min $ V.fromListN 5 [4,2,4,1,3]
    -- [4,2,2,1,1]
    -- >>> V.scanl1 max $ V.fromListN 5 [1,3,2,5,4]
    -- [1,3,3,5,5]
    -- >>> V.scanl1 min (V.empty :: V.Vector Int)
    -- []
    --
    -- @since 0.13.2.0
    scanl1 :: (a -> a -> a) -> Vector a -> Vector a
    {-# INLINE scanl1 #-}
    scanl1 :: forall a. (a -> a -> a) -> Vector a -> Vector a
    scanl1 = (a -> a -> a) -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
    G.scanl1

    -- | /O(n)/ Initial-value free left-to-right scan over a vector with a strict accumulator.
    --
    -- Note: Since 0.13, application of this to an empty vector no longer
    -- results in an error; instead it produces an empty vector.
    --
    -- ==== __Examples__
    -- >>> import qualified Data.Vector as V
    -- >>> V.scanl1' min $ V.fromListN 5 [4,2,4,1,3]
    -- [4,2,2,1,1]
    -- >>> V.scanl1' max $ V.fromListN 5 [1,3,2,5,4]
    -- [1,3,3,5,5]
    -- >>> V.scanl1' min (V.empty :: V.Vector Int)
    -- []
    --
    -- @since 0.13.2.0
    scanl1' :: (a -> a -> a) -> Vector a -> Vector a
    {-# INLINE scanl1' #-}
    scanl1' :: forall a. (a -> a -> a) -> Vector a -> Vector a
    scanl1' = (a -> a -> a) -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
    G.scanl1'

    -- | /O(n)/ Right-to-left prescan.
    --
    -- @
    -- prescanr f z = 'reverse' . 'prescanl' (flip f) z . 'reverse'
    -- @
    --
    -- @since 0.13.2.0
    prescanr :: (a -> b -> b) -> b -> Vector a -> Vector b
    {-# INLINE prescanr #-}
    prescanr :: forall a b. (a -> b -> b) -> b -> Vector a -> Vector b
    prescanr = (a -> b -> b) -> b -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    G.prescanr

    -- | /O(n)/ Right-to-left prescan with strict accumulator.
    --
    -- @since 0.13.2.0
    prescanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
    {-# INLINE prescanr' #-}
    prescanr' :: forall a b. (a -> b -> b) -> b -> Vector a -> Vector b
    prescanr' = (a -> b -> b) -> b -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    G.prescanr'

    -- | /O(n)/ Right-to-left postscan.
    --
    -- @since 0.13.2.0
    postscanr :: (a -> b -> b) -> b -> Vector a -> Vector b
    {-# INLINE postscanr #-}
    postscanr :: forall a b. (a -> b -> b) -> b -> Vector a -> Vector b
    postscanr = (a -> b -> b) -> b -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    G.postscanr

    -- | /O(n)/ Right-to-left postscan with strict accumulator.
    --
    -- @since 0.13.2.0
    postscanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
    {-# INLINE postscanr' #-}
    postscanr' :: forall a b. (a -> b -> b) -> b -> Vector a -> Vector b
    postscanr' = (a -> b -> b) -> b -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    G.postscanr'

    -- | /O(n)/ Right-to-left scan.
    --
    -- @since 0.13.2.0
    scanr :: (a -> b -> b) -> b -> Vector a -> Vector b
    {-# INLINE scanr #-}
    scanr :: forall a b. (a -> b -> b) -> b -> Vector a -> Vector b
    scanr = (a -> b -> b) -> b -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    G.scanr

    -- | /O(n)/ Right-to-left scan with strict accumulator.
    --
    -- @since 0.13.2.0
    scanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
    {-# INLINE scanr' #-}
    scanr' :: forall a b. (a -> b -> b) -> b -> Vector a -> Vector b
    scanr' = (a -> b -> b) -> b -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    G.scanr'

    -- | /O(n)/ Right-to-left scan over a vector with its index.
    --
    -- @since 0.13.2.0
    iscanr :: (Int -> a -> b -> b) -> b -> Vector a -> Vector b
    {-# INLINE iscanr #-}
    iscanr :: forall a b. (Int -> a -> b -> b) -> b -> Vector a -> Vector b
    iscanr = (Int -> a -> b -> b) -> b -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> b -> b) -> b -> v a -> v b
    G.iscanr

    -- | /O(n)/ Right-to-left scan over a vector (strictly) with its index.
    --
    -- @since 0.13.2.0
    iscanr' :: (Int -> a -> b -> b) -> b -> Vector a -> Vector b
    {-# INLINE iscanr' #-}
    iscanr' :: forall a b. (Int -> a -> b -> b) -> b -> Vector a -> Vector b
    iscanr' = (Int -> a -> b -> b) -> b -> Vector a -> Vector b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> b -> b) -> b -> v a -> v b
    G.iscanr'

    -- | /O(n)/ Right-to-left, initial-value free scan over a vector.
    --
    -- Note: Since 0.13, application of this to an empty vector no longer
    -- results in an error; instead it produces an empty vector.
    --
    -- ==== __Examples__
    -- >>> import qualified Data.Vector as V
    -- >>> V.scanr1 min $ V.fromListN 5 [3,1,4,2,4]
    -- [1,1,2,2,4]
    -- >>> V.scanr1 max $ V.fromListN 5 [4,5,2,3,1]
    -- [5,5,3,3,1]
    -- >>> V.scanr1 min (V.empty :: V.Vector Int)
    -- []
    --
    -- @since 0.13.2.0
    scanr1 :: (a -> a -> a) -> Vector a -> Vector a
    {-# INLINE scanr1 #-}
    scanr1 :: forall a. (a -> a -> a) -> Vector a -> Vector a
    scanr1 = (a -> a -> a) -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
    G.scanr1

    -- | /O(n)/ Right-to-left, initial-value free scan over a vector with a strict
    -- accumulator.
    --
    -- Note: Since 0.13, application of this to an empty vector no longer
    -- results in an error; instead it produces an empty vector.
    --
    -- ==== __Examples__
    -- >>> import qualified Data.Vector as V
    -- >>> V.scanr1' min $ V.fromListN 5 [3,1,4,2,4]
    -- [1,1,2,2,4]
    -- >>> V.scanr1' max $ V.fromListN 5 [4,5,2,3,1]
    -- [5,5,3,3,1]
    -- >>> V.scanr1' min (V.empty :: V.Vector Int)
    -- []
    --
    -- @since 0.13.2.0
    scanr1' :: (a -> a -> a) -> Vector a -> Vector a
    {-# INLINE scanr1' #-}
    scanr1' :: forall a. (a -> a -> a) -> Vector a -> Vector a
    scanr1' = (a -> a -> a) -> Vector a -> Vector a
    forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
    G.scanr1'

    -- Comparisons
    -- ------------------------

    -- | /O(n)/ Check if two vectors are equal using the supplied equality
    -- predicate.
    --
    -- @since 0.13.2.0
    eqBy :: (a -> b -> Bool) -> Vector a -> Vector b -> Bool
    {-# INLINE eqBy #-}
    eqBy :: forall a b. (a -> b -> Bool) -> Vector a -> Vector b -> Bool
    eqBy = (a -> b -> Bool) -> Vector a -> Vector b -> Bool
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> Bool) -> v a -> v b -> Bool
    G.eqBy

    -- | /O(n)/ Compare two vectors using the supplied comparison function for
    -- vector elements. Comparison works the same as for lists.
    --
    -- > cmpBy compare == compare
    --
    -- @since 0.13.2.0
    cmpBy :: (a -> b -> Ordering) -> Vector a -> Vector b -> Ordering
    cmpBy :: forall a b.
    (a -> b -> Ordering) -> Vector a -> Vector b -> Ordering
    cmpBy = (a -> b -> Ordering) -> Vector a -> Vector b -> Ordering
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> Ordering) -> v a -> v b -> Ordering
    G.cmpBy

    -- Conversions - Lists
    -- ------------------------

    -- | /O(n)/ Convert a vector to a list.
    --
    -- @since 0.13.2.0
    toList :: Vector a -> [a]
    {-# INLINE toList #-}
    toList :: forall a. Vector a -> [a]
    toList = Vector a -> [a]
    forall (v :: * -> *) a. Vector v a => v a -> [a]
    G.toList

    -- | /O(n)/ Convert a list to a vector. During the operation, the
    -- vector’s capacity will be doubling until the list's contents are
    -- in the vector. Depending on the list’s size, up to half of the vector’s
    -- capacity might be empty. If you’d rather avoid this, you can use
    -- 'fromListN', which will provide the exact space the list requires but will
    -- prevent list fusion, or @'force' . 'fromList'@, which will create the
    -- vector and then copy it without the superfluous space.
    --
    -- @since 0.13.2.0
    fromList :: [a] -> Vector a
    {-# INLINE fromList #-}
    fromList :: forall a. [a] -> Vector a
    fromList = [a] -> Vector a
    forall (v :: * -> *) a. Vector v a => [a] -> v a
    G.fromList

    -- | /O(n)/ Convert the first @n@ elements of a list to a vector. It's
    -- expected that the supplied list will be exactly @n@ elements long. As
    -- an optimization, this function allocates a buffer for @n@ elements, which
    -- could be used for DoS-attacks by exhausting the memory if an attacker controls
    -- that parameter.
    --
    -- @
    -- fromListN n xs = 'fromList' ('take' n xs)
    -- @
    --
    -- @since 0.13.2.0
    fromListN :: Int -> [a] -> Vector a
    {-# INLINE fromListN #-}
    fromListN :: forall a. Int -> [a] -> Vector a
    fromListN = Int -> [a] -> Vector a
    forall (v :: * -> *) a. Vector v a => Int -> [a] -> v a
    G.fromListN

    -- Conversions - Lazy vectors
    -- -----------------------------

    -- | /O(1)/ Convert strict array to lazy array
    toLazy :: Vector a -> V.Vector a
    toLazy :: forall a. Vector a -> Vector a
    toLazy (Vector Vector a
    v) = Vector a
    v

    -- | /O(n)/ Convert lazy array to strict array. This function reduces
    -- each element of vector to WHNF.
    fromLazy :: V.Vector a -> Vector a
    fromLazy :: forall a. Vector a -> Vector a
    fromLazy Vector a
    vec = (a -> ()) -> Vector a -> ()
    forall a. (a -> ()) -> Vector a -> ()
    liftRnfV (a -> () -> ()
    forall a b. a -> b -> b
    `seq` ()) Vector a
    v () -> Vector a -> Vector a
    forall a b. a -> b -> b
    `seq` Vector a
    v where v :: Vector a
    v = Vector a -> Vector a
    forall a. Vector a -> Vector a
    Vector Vector a
    vec

    -- Conversions - Arrays
    -- -----------------------------

    -- | /O(n)/ Convert an array to a vector and reduce each element to WHNF.
    --
    -- @since 0.13.2.0
    fromArray :: Array a -> Vector a
    {-# INLINE fromArray #-}
    fromArray :: forall a. Array a -> Vector a
    fromArray Array a
    arr = (a -> ()) -> Vector a -> ()
    forall a. (a -> ()) -> Vector a -> ()
    liftRnfV (a -> () -> ()
    forall a b. a -> b -> b
    `seq` ()) Vector a
    vec () -> Vector a -> Vector a
    forall a b. a -> b -> b
    `seq` Vector a
    vec
      where
        vec :: Vector a
    vec = Vector a -> Vector a
    forall a. Vector a -> Vector a
    Vector (Vector a -> Vector a) -> Vector a -> Vector a
    forall a b. (a -> b) -> a -> b
    $ Array a -> Vector a
    forall a. Array a -> Vector a
    V.fromArray Array a
    arr

    -- | /O(n)/ Convert a vector to an array.
    --
    -- @since 0.13.2.0
    toArray :: Vector a -> Array a
    {-# INLINE toArray #-}
    toArray :: forall a. Vector a -> Array a
    toArray (Vector Vector a
    v) = Vector a -> Array a
    forall a. Vector a -> Array a
    V.toArray Vector a
    v

    -- | /O(1)/ Extract the underlying `Array`, offset where vector starts and the
    -- total number of elements in the vector. Below property always holds:
    --
    -- > let (array, offset, len) = toArraySlice v
    -- > v === unsafeFromArraySlice len offset array
    --
    -- @since 0.13.2.0
    toArraySlice :: Vector a -> (Array a, Int, Int)
    {-# INLINE toArraySlice #-}
    toArraySlice :: forall a. Vector a -> (Array a, Int, Int)
    toArraySlice (Vector Vector a
    v) = Vector a -> (Array a, Int, Int)
    forall a. Vector a -> (Array a, Int, Int)
    V.toArraySlice Vector a
    v

    -- | /O(n)/ Convert an array slice to a vector and reduce each element to WHNF.
    --
    -- This function is very unsafe, because constructing an invalid
    -- vector can yield almost all other safe functions in this module
    -- unsafe. These are equivalent:
    --
    -- > unsafeFromArraySlice len offset === unsafeTake len . unsafeDrop offset . fromArray
    --
    -- @since 0.13.2.0
    unsafeFromArraySlice ::
         Array a -- ^ Immutable boxed array.
      -> Int -- ^ Offset
      -> Int -- ^ Length
      -> Vector a
    {-# INLINE unsafeFromArraySlice #-}
    unsafeFromArraySlice :: forall a. Array a -> Int -> Int -> Vector a
    unsafeFromArraySlice Array a
    arr Int
    offset Int
    len = (a -> ()) -> Vector a -> ()
    forall a. (a -> ()) -> Vector a -> ()
    liftRnfV (a -> () -> ()
    forall a b. a -> b -> b
    `seq` ()) Vector a
    vec () -> Vector a -> Vector a
    forall a b. a -> b -> b
    `seq` Vector a
    vec
      where vec :: Vector a
    vec = Vector a -> Vector a
    forall a. Vector a -> Vector a
    Vector (Array a -> Int -> Int -> Vector a
    forall a. Array a -> Int -> Int -> Vector a
    V.unsafeFromArraySlice Array a
    arr Int
    offset Int
    len)

    -- Conversions - Mutable vectors
    -- -----------------------------

    -- | /O(1)/ Unsafely convert a mutable vector to an immutable one without
    -- copying. The mutable vector may not be used after this operation.
    --
    -- @since 0.13.2.0
    unsafeFreeze :: PrimMonad m => MVector (PrimState m) a -> m (Vector a)
    {-# INLINE unsafeFreeze #-}
    unsafeFreeze :: forall (m :: * -> *) a.
    PrimMonad m =>
    MVector (PrimState m) a -> m (Vector a)
    unsafeFreeze = Mutable Vector (PrimState m) a -> m (Vector a)
    MVector (PrimState m) a -> m (Vector a)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m (v a)
    G.unsafeFreeze

    -- | /O(n)/ Yield an immutable copy of the mutable vector.
    --
    -- @since 0.13.2.0
    freeze :: PrimMonad m => MVector (PrimState m) a -> m (Vector a)
    {-# INLINE freeze #-}
    freeze :: forall (m :: * -> *) a.
    PrimMonad m =>
    MVector (PrimState m) a -> m (Vector a)
    freeze = Mutable Vector (PrimState m) a -> m (Vector a)
    MVector (PrimState m) a -> m (Vector a)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m (v a)
    G.freeze

    -- | /O(1)/ Unsafely convert an immutable vector to a mutable one
    -- without copying. Note that this is a very dangerous function and
    -- generally it's only safe to read from the resulting vector. In this
    -- case, the immutable vector could be used safely as well.
    --
    -- Problems with mutation happen because GHC has a lot of freedom to
    -- introduce sharing. As a result mutable vectors produced by
    -- @unsafeThaw@ may or may not share the same underlying buffer. For
    -- example:
    --
    -- > foo = do
    -- >   let vec = V.generate 10 id
    -- >   mvec <- V.unsafeThaw vec
    -- >   do_something mvec
    --
    -- Here GHC could lift @vec@ outside of foo which means that all calls to
    -- @do_something@ will use same buffer with possibly disastrous
    -- results. Whether such aliasing happens or not depends on the program in
    -- question, optimization levels, and GHC flags.
    --
    -- All in all, attempts to modify a vector produced by @unsafeThaw@ fall out of
    -- domain of software engineering and into realm of black magic, dark
    -- rituals, and unspeakable horrors. The only advice that could be given
    -- is: "Don't attempt to mutate a vector produced by @unsafeThaw@ unless you
    -- know how to prevent GHC from aliasing buffers accidentally. We don't."
    --
    -- @since 0.13.2.0
    unsafeThaw :: PrimMonad m => Vector a -> m (MVector (PrimState m) a)
    {-# INLINE unsafeThaw #-}
    unsafeThaw :: forall (m :: * -> *) a.
    PrimMonad m =>
    Vector a -> m (MVector (PrimState m) a)
    unsafeThaw = Vector a -> m (Mutable Vector (PrimState m) a)
    Vector a -> m (MVector (PrimState m) a)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    v a -> m (Mutable v (PrimState m) a)
    G.unsafeThaw

    -- | /O(n)/ Yield a mutable copy of an immutable vector.
    --
    -- @since 0.13.2.0
    thaw :: PrimMonad m => Vector a -> m (MVector (PrimState m) a)
    {-# INLINE thaw #-}
    thaw :: forall (m :: * -> *) a.
    PrimMonad m =>
    Vector a -> m (MVector (PrimState m) a)
    thaw = Vector a -> m (Mutable Vector (PrimState m) a)
    Vector a -> m (MVector (PrimState m) a)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    v a -> m (Mutable v (PrimState m) a)
    G.thaw

    -- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
    -- have the same length. This is not checked.
    --
    -- @since 0.13.2.0
    unsafeCopy :: PrimMonad m => MVector (PrimState m) a -> Vector a -> m ()
    {-# INLINE unsafeCopy #-}
    unsafeCopy :: forall (m :: * -> *) a.
    PrimMonad m =>
    MVector (PrimState m) a -> Vector a -> m ()
    unsafeCopy = Mutable Vector (PrimState m) a -> Vector a -> m ()
    MVector (PrimState m) a -> Vector a -> m ()
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> v a -> m ()
    G.unsafeCopy

    -- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
    -- have the same length.
    --
    -- @since 0.13.2.0
    copy :: PrimMonad m => MVector (PrimState m) a -> Vector a -> m ()
    {-# INLINE copy #-}
    copy :: forall (m :: * -> *) a.
    PrimMonad m =>
    MVector (PrimState m) a -> Vector a -> m ()
    copy = Mutable Vector (PrimState m) a -> Vector a -> m ()
    MVector (PrimState m) a -> Vector a -> m ()
    forall (m :: * -> *) (v :: * -> *) a.
    (HasCallStack, PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> v a -> m ()
    G.copy

    -- $setup
    -- >>> :set -Wno-type-defaults
    -- >>> import Prelude (Char, String, Bool(True, False), min, max, fst, even, undefined, Ord(..))