    {-# LANGUAGE BangPatterns #-}
    {-# LANGUAGE CPP #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE RankNTypes #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE TypeFamilies #-}
    -- |
    -- Module      : Data.Vector.Generic
    -- 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
    --
    -- Generic interface to immutable vectors.

    module Data.Vector.Generic (
      -- * Immutable vectors
      Vector(..), Mutable,

      -- * 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, concatNE,

      -- ** 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,
      takeWhile, dropWhile,

      -- ** Partitioning
      partition, partitionWith, unstablePartition, 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',

      -- * Conversions

      -- ** Lists
      toList, fromList, fromListN,

      -- ** Different vector types
      convert,

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

      -- * Fusion support

      -- ** Conversion to/from Bundles
      stream, unstream, unstreamM, streamR, unstreamR,

      -- ** Recycling support
      new, clone,

      -- * Utilities

      -- ** Comparisons
      eq, cmp,
      eqBy, cmpBy,

      -- ** Show and Read
      showsPrec, readPrec,
      liftShowsPrec, liftReadsPrec,

      -- ** @Data@ and @Typeable@
      gfoldl, gunfold, dataCast, mkVecType, mkVecConstr, mkType
    ) where

    import           Data.Vector.Generic.Base

    import qualified Data.Vector.Generic.Mutable as M

    import qualified Data.Vector.Generic.New as New
    import           Data.Vector.Generic.New ( New )

    import qualified Data.Vector.Fusion.Bundle as Bundle
    import           Data.Vector.Fusion.Bundle ( Bundle, MBundle, lift, inplace )
    import qualified Data.Vector.Fusion.Bundle.Monadic as MBundle
    import           Data.Vector.Fusion.Stream.Monadic ( Stream )
    import qualified Data.Vector.Fusion.Stream.Monadic as S
    import           Data.Vector.Fusion.Bundle.Size
    import           Data.Vector.Fusion.Util
    import           Data.Vector.Internal.Check

    import Control.Monad.ST ( ST, runST )
    import Control.Monad.Primitive
    import Prelude
      ( Eq, Ord, Num, Enum, Monoid, Monad, Read, Show, Bool, Ordering(..), Int, Maybe(..), Either, IO, ShowS, ReadS, String
      , compare, mempty, mappend, return, fmap, otherwise, id, flip, seq, error, undefined, uncurry, shows, fst, snd, min, max, not
      , (>>=), (+), (-), (*), (<), (==), (.), ($), (=<<), (>>), (<$>) )

    import qualified Text.Read as Read
    import qualified Data.List.NonEmpty as NonEmpty

    import Data.Typeable ( Typeable, gcast1 )

    #include "vector.h"

    import Data.Data ( Data, DataType, Constr, Fixity(Prefix),
                       mkDataType, mkConstr, constrIndex, mkNoRepType )
    import qualified Data.Traversable as T (Traversable(mapM))

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

    -- | /O(1)/ Yield the length of the vector.
    length :: Vector v a => v a -> Int
    {-# INLINE length #-}
    length :: forall (v :: * -> *) a. Vector v a => v a -> Int
    length = Bundle v a -> Int
    forall (v :: * -> *) a. Bundle v a -> Int
    Bundle.length (Bundle v a -> Int) -> (v a -> Bundle v a) -> v a -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(1)/ Test whether a vector is empty.
    null :: Vector v a => v a -> Bool
    {-# INLINE null #-}
    null :: forall (v :: * -> *) a. Vector v a => v a -> Bool
    null = Bundle v a -> Bool
    forall (v :: * -> *) a. Bundle v a -> Bool
    Bundle.null (Bundle v a -> Bool) -> (v a -> Bundle v a) -> v a -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

    -- NOTE: [Strict indexing]
    -- ~~~~~~~~~~~~~~~~~~~~~~~
    --
    -- Why index parameters are strict in indexing ((!), (!?)) functions
    -- and functions for accessing elements in mutable arrays ('unsafeRead',
    -- 'unsafeWrite', 'unsafeModify'), and slice functions?
    --
    -- These function call class methods ('basicUnsafeIndexM',
    -- 'basicUnsafeRead', etc) and, unless (!) was already specialised to
    -- a specific v, GHC has no clue that i is most certainly to be used
    -- eagerly. Bang before i hints this vital for optimizer information.

    infixl 9 !
    -- | O(1) Indexing.
    (!) :: (HasCallStack, Vector v a) => v a -> Int -> a
    {-# INLINE_FUSED (!) #-}
    -- See NOTE: [Strict indexing]
    ! :: forall (v :: * -> *) a.
    (HasCallStack, Vector v a) =>
    v a -> Int -> a
    (!) v a
    v !Int
    i = Checks -> Int -> Int -> a -> a
    forall a. HasCallStack => Checks -> Int -> Int -> a -> a
    checkIndex Checks
    Bounds Int
    i (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v) (a -> a) -> a -> a
    forall a b. (a -> b) -> a -> b
    $ Box a -> a
    forall a. Box a -> a
    unBox (v a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    basicUnsafeIndexM v a
    v Int
    i)

    infixl 9 !?
    -- | O(1) Safe indexing.
    (!?) :: Vector v a => v a -> Int -> Maybe a
    {-# INLINE_FUSED (!?) #-}
    -- See NOTE: [Strict indexing]
    -- Use basicUnsafeIndexM @Box to perform the indexing eagerly.
    v a
    v !? :: forall (v :: * -> *) a. Vector v a => v a -> Int -> Maybe a
    !? (!Int
    i)
      | Int
    i Int -> Int -> Bool
    `inRange` v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v = case v a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    basicUnsafeIndexM v a
    v Int
    i of Box a
    a -> a -> Maybe a
    forall a. a -> Maybe a
    Just a
    a
      | Bool
    otherwise            = Maybe a
    forall a. Maybe a
    Nothing

    -- | /O(1)/ First element.
    head :: Vector v a => v a -> a
    {-# INLINE_FUSED head #-}
    head :: forall (v :: * -> *) a. Vector v a => v a -> a
    head v a
    v = v a
    v v a -> Int -> a
    forall (v :: * -> *) a.
    (HasCallStack, Vector v a) =>
    v a -> Int -> a
    ! Int
    0

    -- | /O(1)/ Last element.
    last :: Vector v a => v a -> a
    {-# INLINE_FUSED last #-}
    last :: forall (v :: * -> *) a. Vector v a => v a -> a
    last v a
    v = v a
    v v a -> Int -> a
    forall (v :: * -> *) a.
    (HasCallStack, Vector v a) =>
    v a -> Int -> a
    ! (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1)

    -- | /O(1)/ Unsafe indexing without bounds checking.
    unsafeIndex :: Vector v a => v a -> Int -> a
    {-# INLINE_FUSED unsafeIndex #-}
    -- See NOTE: [Strict indexing]
    unsafeIndex :: forall (v :: * -> *) a. Vector v a => v a -> Int -> a
    unsafeIndex v a
    v !Int
    i = Checks -> Int -> Int -> a -> a
    forall a. HasCallStack => Checks -> Int -> Int -> a -> a
    checkIndex Checks
    Unsafe Int
    i (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v) (a -> a) -> a -> a
    forall a b. (a -> b) -> a -> b
    $ Box a -> a
    forall a. Box a -> a
    unBox (v a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    basicUnsafeIndexM v a
    v Int
    i)

    -- | /O(1)/ First element, without checking if the vector is empty.
    unsafeHead :: Vector v a => v a -> a
    {-# INLINE_FUSED unsafeHead #-}
    unsafeHead :: forall (v :: * -> *) a. Vector v a => v a -> a
    unsafeHead v a
    v = v a -> Int -> a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> a
    unsafeIndex v a
    v Int
    0

    -- | /O(1)/ Last element, without checking if the vector is empty.
    unsafeLast :: Vector v a => v a -> a
    {-# INLINE_FUSED unsafeLast #-}
    unsafeLast :: forall (v :: * -> *) a. Vector v a => v a -> a
    unsafeLast v a
    v = v a -> Int -> a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> a
    unsafeIndex v a
    v (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1)

    {-# RULES

    "(!)/unstream [Vector]" forall i s.
      new (New.unstream s) ! i = s Bundle.!! i

    "(!?)/unstream [Vector]" forall i s.
      new (New.unstream s) !? i = s Bundle.!? i

    "head/unstream [Vector]" forall s.
      head (new (New.unstream s)) = Bundle.head s

    "last/unstream [Vector]" forall s.
      last (new (New.unstream s)) = Bundle.last s

    "unsafeIndex/unstream [Vector]" forall i s.
      unsafeIndex (new (New.unstream s)) i = s Bundle.!! i

    "unsafeHead/unstream [Vector]" forall s.
      unsafeHead (new (New.unstream s)) = Bundle.head s

    "unsafeLast/unstream [Vector]" forall s.
      unsafeLast (new (New.unstream s)) = Bundle.last s  #-}

    -- 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.
    indexM :: (HasCallStack, Vector v a, Monad m) => v a -> Int -> m a
    {-# INLINE_FUSED indexM #-}
    indexM :: forall (v :: * -> *) a (m :: * -> *).
    (HasCallStack, Vector v a, Monad m) =>
    v a -> Int -> m a
    indexM v a
    v !Int
    i = Checks -> Int -> Int -> m a -> m a
    forall a. HasCallStack => Checks -> Int -> Int -> a -> a
    checkIndex Checks
    Bounds Int
    i (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v) (m a -> m a) -> m a -> m a
    forall a b. (a -> b) -> a -> b
    $ Box a -> m a
    forall (m :: * -> *) a. Monad m => Box a -> m a
    liftBox (Box a -> m a) -> Box a -> m a
    forall a b. (a -> b) -> a -> b
    $ v a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    basicUnsafeIndexM v a
    v Int
    i

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

    -- | /O(1)/ Last element of a vector in a monad. See 'indexM' for an
    -- explanation of why this is useful.
    lastM :: (Vector v a, Monad m) => v a -> m a
    {-# INLINE_FUSED lastM #-}
    lastM :: forall (v :: * -> *) a (m :: * -> *).
    (Vector v a, Monad m) =>
    v a -> m a
    lastM v a
    v = v a -> Int -> m a
    forall (v :: * -> *) a (m :: * -> *).
    (HasCallStack, Vector v a, Monad m) =>
    v a -> Int -> m a
    indexM v a
    v (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1)

    -- | /O(1)/ Indexing in a monad, without bounds checks. See 'indexM' for an
    -- explanation of why this is useful.
    unsafeIndexM :: (Vector v a, Monad m) => v a -> Int -> m a
    {-# INLINE_FUSED unsafeIndexM #-}
    unsafeIndexM :: forall (v :: * -> *) a (m :: * -> *).
    (Vector v a, Monad m) =>
    v a -> Int -> m a
    unsafeIndexM v a
    v !Int
    i = Checks -> Int -> Int -> m a -> m a
    forall a. HasCallStack => Checks -> Int -> Int -> a -> a
    checkIndex Checks
    Unsafe Int
    i (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v)
                     (m a -> m a) -> m a -> m a
    forall a b. (a -> b) -> a -> b
    $ Box a -> m a
    forall (m :: * -> *) a. Monad m => Box a -> m a
    liftBox
                     (Box a -> m a) -> Box a -> m a
    forall a b. (a -> b) -> a -> b
    $ v a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    basicUnsafeIndexM v a
    v Int
    i

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

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

    {-# RULES

    "indexM/unstream [Vector]" forall s i.
      indexM (new (New.unstream s)) i = lift s MBundle.!! i

    "headM/unstream [Vector]" forall s.
      headM (new (New.unstream s)) = MBundle.head (lift s)

    "lastM/unstream [Vector]" forall s.
      lastM (new (New.unstream s)) = MBundle.last (lift s)

    "unsafeIndexM/unstream [Vector]" forall s i.
      unsafeIndexM (new (New.unstream s)) i = lift s MBundle.!! i

    "unsafeHeadM/unstream [Vector]" forall s.
      unsafeHeadM (new (New.unstream s)) = MBundle.head (lift s)

    "unsafeLastM/unstream [Vector]" forall s.
      unsafeLastM (new (New.unstream s)) = MBundle.last (lift s)   #-}

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

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

    -- | /O(1)/ Yield all but the last element without copying. The vector may not
    -- be empty.
    init :: Vector v a => v a -> v a
    {-# INLINE_FUSED init #-}
    init :: forall (v :: * -> *) a. Vector v a => v a -> v a
    init v a
    v = Int -> Int -> v a -> v a
    forall (v :: * -> *) a.
    (HasCallStack, Vector v a) =>
    Int -> Int -> v a -> v a
    slice Int
    0 (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1) v a
    v

    -- | /O(1)/ Yield all but the first element without copying. The vector may not
    -- be empty.
    tail :: Vector v a => v a -> v a
    {-# INLINE_FUSED tail #-}
    tail :: forall (v :: * -> *) a. Vector v a => v a -> v a
    tail v a
    v = Int -> Int -> v a -> v a
    forall (v :: * -> *) a.
    (HasCallStack, Vector v a) =>
    Int -> Int -> v a -> v a
    slice Int
    1 (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1) v a
    v

    -- | /O(1)/ Yield the first @n@ elements without copying. The vector may
    -- contain less than @n@ elements, in which case it is returned unchanged.
    take :: Vector v a => Int -> v a -> v a
    {-# INLINE_FUSED take #-}
    take :: forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
    take Int
    n v a
    v = Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice Int
    0 ((Int -> Int -> Int) -> Int -> Int -> Int
    forall a b. (a -> b) -> a -> b
    delay_inline Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    min Int
    n' (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v)) v a
    v
      where n' :: Int
    n' = Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    max Int
    n Int
    0

    -- | /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.
    drop :: Vector v a => Int -> v a -> v a
    {-# INLINE_FUSED drop #-}
    drop :: forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
    drop Int
    n v a
    v = Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice ((Int -> Int -> Int) -> Int -> Int -> Int
    forall a b. (a -> b) -> a -> b
    delay_inline Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    min Int
    n' Int
    len)
                           ((Int -> Int -> Int) -> Int -> Int -> Int
    forall a b. (a -> b) -> a -> b
    delay_inline Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    max Int
    0 (Int
    len Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    n')) v a
    v
      where n' :: Int
    n' = Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    max Int
    n Int
    0
            len :: Int
    len = v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v

    -- | /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.7.1
    splitAt :: Vector v a => Int -> v a -> (v a, v a)
    {-# INLINE_FUSED splitAt #-}
    splitAt :: forall (v :: * -> *) a. Vector v a => Int -> v a -> (v a, v a)
    splitAt Int
    n v a
    v = ( Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice Int
    0 Int
    m v a
    v
                  , Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice Int
    m ((Int -> Int -> Int) -> Int -> Int -> Int
    forall a b. (a -> b) -> a -> b
    delay_inline Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    max Int
    0 (Int
    len Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    n')) v a
    v
                  )
        where
          m :: Int
    m   = (Int -> Int -> Int) -> Int -> Int -> Int
    forall a b. (a -> b) -> a -> b
    delay_inline Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    min Int
    n' Int
    len
          n' :: Int
    n'  = Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    max Int
    n Int
    0
          len :: Int
    len = v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v

    -- | /O(1)/ Yield the 'head' and 'tail' of the vector, or 'Nothing' if
    -- the vector is empty.
    --
    -- @since 0.12.2.0
    uncons :: Vector v a => v a -> Maybe (a, v a)
    {-# INLINE_FUSED uncons #-}
    uncons :: forall (v :: * -> *) a. Vector v a => v a -> Maybe (a, v a)
    uncons v a
    xs = (a -> v a -> (a, v a)) -> v a -> a -> (a, v a)
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (,) (v a -> v a
    forall (v :: * -> *) a. Vector v a => v a -> v a
    unsafeTail v a
    xs) (a -> (a, v a)) -> Maybe a -> Maybe (a, v a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> v a
    xs v a -> Int -> Maybe a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Maybe a
    !? Int
    0

    -- | /O(1)/ Yield the 'last' and 'init' of the vector, or 'Nothing' if
    -- the vector is empty.
    --
    -- @since 0.12.2.0
    unsnoc :: Vector v a => v a -> Maybe (v a, a)
    {-# INLINE_FUSED unsnoc #-}
    unsnoc :: forall (v :: * -> *) a. Vector v a => v a -> Maybe (v a, a)
    unsnoc v a
    xs = (,) (v a -> v a
    forall (v :: * -> *) a. Vector v a => v a -> v a
    unsafeInit v a
    xs) (a -> (v a, a)) -> Maybe a -> Maybe (v a, a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> v a
    xs v a -> Int -> Maybe a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Maybe a
    !? (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    xs Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1)

    -- | /O(1)/ Yield a slice of the vector without copying. The vector must
    -- contain at least @i+n@ elements, but this is not checked.
    unsafeSlice :: Vector v a => Int   -- ^ @i@ starting index
                              -> Int   -- ^ @n@ length
                              -> v a
                              -> v a
    {-# INLINE_FUSED unsafeSlice #-}
    -- See NOTE: [Strict indexing]
    unsafeSlice :: forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice !Int
    i !Int
    n v a
    v = Checks -> Int -> Int -> Int -> v a -> v a
    forall a. HasCallStack => Checks -> Int -> Int -> Int -> a -> a
    checkSlice Checks
    Unsafe Int
    i Int
    n (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v) (v a -> v a) -> v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    basicUnsafeSlice Int
    i Int
    n v a
    v

    -- | /O(1)/ Yield all but the last element without copying. The vector may not
    -- be empty, but this is not checked.
    unsafeInit :: Vector v a => v a -> v a
    {-# INLINE_FUSED unsafeInit #-}
    unsafeInit :: forall (v :: * -> *) a. Vector v a => v a -> v a
    unsafeInit v a
    v = Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice Int
    0 (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1) v a
    v

    -- | /O(1)/ Yield all but the first element without copying. The vector may not
    -- be empty, but this is not checked.
    unsafeTail :: Vector v a => v a -> v a
    {-# INLINE_FUSED unsafeTail #-}
    unsafeTail :: forall (v :: * -> *) a. Vector v a => v a -> v a
    unsafeTail v a
    v = Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice Int
    1 (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1) v a
    v

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

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

    -- Turned off due to: https://github.com/haskell/vector/issues/257
    -- "slice/new [Vector]" forall i n p.
    --   slice i n (new p) = new (New.slice i n p)

    {-# RULES

    "init/new [Vector]" forall p.
      init (new p) = new (New.init p)

    "tail/new [Vector]" forall p.
      tail (new p) = new (New.tail p)

    "take/new [Vector]" forall n p.
      take n (new p) = new (New.take n p)

    "drop/new [Vector]" forall n p.
      drop n (new p) = new (New.drop n p)

    "unsafeSlice/new [Vector]" forall i n p.
      unsafeSlice i n (new p) = new (New.unsafeSlice i n p)

    "unsafeInit/new [Vector]" forall p.
      unsafeInit (new p) = new (New.unsafeInit p)

    "unsafeTail/new [Vector]" forall p.
      unsafeTail (new p) = new (New.unsafeTail p)   #-}

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

    -- | /O(1)/ The empty vector.
    empty :: Vector v a => v a
    {-# INLINE empty #-}
    empty :: forall (v :: * -> *) a. Vector v a => v a
    empty = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream Bundle v a
    forall (v :: * -> *) a. Bundle v a
    Bundle.empty

    -- | /O(1)/ A vector with exactly one element.
    singleton :: forall v a. Vector v a => a -> v a
    {-# INLINE singleton #-}
    singleton :: forall (v :: * -> *) a. Vector v a => a -> v a
    singleton a
    x = v a -> a -> v a -> v a
    forall b. v a -> a -> b -> b
    forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
    elemseq (v a
    forall a. HasCallStack => a
    undefined :: v a) a
    x
                (v a -> v a) -> v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (a -> Bundle v a
    forall a (v :: * -> *). a -> Bundle v a
    Bundle.singleton a
    x)

    -- | /O(n)/ A vector of the given length with the same value in each position.
    replicate :: forall v a. Vector v a => Int -> a -> v a
    {-# INLINE replicate #-}
    replicate :: forall (v :: * -> *) a. Vector v a => Int -> a -> v a
    replicate Int
    n a
    x = v a -> a -> v a -> v a
    forall b. v a -> a -> b -> b
    forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
    elemseq (v a
    forall a. HasCallStack => a
    undefined :: v a) a
    x
                  (v a -> v a) -> v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
                  (Bundle v a -> v a) -> Bundle v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Int -> a -> Bundle v a
    forall a (v :: * -> *). Int -> a -> Bundle v a
    Bundle.replicate Int
    n a
    x

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

    -- | /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}} \)
    --
    -- @since 0.7.1
    iterateN :: Vector v a => Int -> (a -> a) -> a -> v a
    {-# INLINE iterateN #-}
    iterateN :: forall (v :: * -> *) a. Vector v a => Int -> (a -> a) -> a -> v a
    iterateN Int
    n a -> a
    f a
    x = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Int -> (a -> a) -> a -> Bundle v a
    forall a (v :: * -> *). Int -> (a -> a) -> a -> Bundle v a
    Bundle.iterateN Int
    n a -> a
    f a
    x)

    -- 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>
    unfoldr :: Vector v a => (b -> Maybe (a, b)) -> b -> v a
    {-# INLINE unfoldr #-}
    unfoldr :: forall (v :: * -> *) a b.
    Vector v a =>
    (b -> Maybe (a, b)) -> b -> v a
    unfoldr b -> Maybe (a, b)
    f = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (b -> Bundle v a) -> b -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (b -> Maybe (a, b)) -> b -> Bundle v a
    forall s a (v :: * -> *). (s -> Maybe (a, s)) -> s -> Bundle v a
    Bundle.unfoldr b -> Maybe (a, b)
    f

    -- | /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>
    unfoldrN  :: Vector v a => Int -> (b -> Maybe (a, b)) -> b -> v a
    {-# INLINE unfoldrN #-}
    unfoldrN :: forall (v :: * -> *) a b.
    Vector v a =>
    Int -> (b -> Maybe (a, b)) -> b -> v a
    unfoldrN Int
    n b -> Maybe (a, b)
    f = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (b -> Bundle v a) -> b -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> (b -> Maybe (a, b)) -> b -> Bundle v a
    forall s a (v :: * -> *).
    Int -> (s -> Maybe (a, s)) -> s -> Bundle v a
    Bundle.unfoldrN Int
    n b -> Maybe (a, b)
    f

    -- | /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.12.2.0
    unfoldrExactN  :: Vector v a => Int -> (b -> (a, b)) -> b -> v a
    {-# INLINE unfoldrExactN #-}
    unfoldrExactN :: forall (v :: * -> *) a b.
    Vector v a =>
    Int -> (b -> (a, b)) -> b -> v a
    unfoldrExactN Int
    n b -> (a, b)
    f = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (b -> Bundle v a) -> b -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> (b -> (a, b)) -> b -> Bundle v a
    forall s a (v :: * -> *). Int -> (s -> (a, s)) -> s -> Bundle v a
    Bundle.unfoldrExactN Int
    n b -> (a, b)
    f

    -- | /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.
    unfoldrM :: (Monad m, Vector v a) => (b -> m (Maybe (a, b))) -> b -> m (v a)
    {-# INLINE unfoldrM #-}
    unfoldrM :: forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    (b -> m (Maybe (a, b))) -> b -> m (v a)
    unfoldrM b -> m (Maybe (a, b))
    f = MBundle m (ZonkAny 9) a -> m (v a)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (MBundle m (ZonkAny 9) a -> m (v a))
    -> (b -> MBundle m (ZonkAny 9) a) -> b -> m (v a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (b -> m (Maybe (a, b))) -> b -> MBundle m (ZonkAny 9) a
    forall (m :: * -> *) s a (u :: * -> *).
    Monad m =>
    (s -> m (Maybe (a, s))) -> s -> Bundle m u a
    MBundle.unfoldrM b -> m (Maybe (a, b))
    f

    -- | /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.
    unfoldrNM :: (Monad m, Vector v a) => Int -> (b -> m (Maybe (a, b))) -> b -> m (v a)
    {-# INLINE unfoldrNM #-}
    unfoldrNM :: forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    Int -> (b -> m (Maybe (a, b))) -> b -> m (v a)
    unfoldrNM Int
    n b -> m (Maybe (a, b))
    f = MBundle m (ZonkAny 8) a -> m (v a)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (MBundle m (ZonkAny 8) a -> m (v a))
    -> (b -> MBundle m (ZonkAny 8) a) -> b -> m (v a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> (b -> m (Maybe (a, b))) -> b -> MBundle m (ZonkAny 8) a
    forall (m :: * -> *) s a (u :: * -> *).
    Monad m =>
    Int -> (s -> m (Maybe (a, s))) -> s -> Bundle m u a
    MBundle.unfoldrNM Int
    n b -> m (Maybe (a, b))
    f

    -- | /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.12.2.0
    unfoldrExactNM :: (Monad m, Vector v a) => Int -> (b -> m (a, b)) -> b -> m (v a)
    {-# INLINE unfoldrExactNM #-}
    unfoldrExactNM :: forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    Int -> (b -> m (a, b)) -> b -> m (v a)
    unfoldrExactNM Int
    n b -> m (a, b)
    f = MBundle m (ZonkAny 7) a -> m (v a)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (MBundle m (ZonkAny 7) a -> m (v a))
    -> (b -> MBundle m (ZonkAny 7) a) -> b -> m (v a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> (b -> m (a, b)) -> b -> MBundle m (ZonkAny 7) a
    forall (m :: * -> *) s a (u :: * -> *).
    Monad m =>
    Int -> (s -> m (a, s)) -> s -> Bundle m u a
    MBundle.unfoldrExactNM Int
    n b -> m (a, b)
    f

    -- | /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>
    constructN :: forall v a. Vector v a => Int -> (v a -> a) -> v a
    {-# INLINE constructN #-}
    -- NOTE: We *CANNOT* wrap this in New and then fuse because the elements
    -- might contain references to the immutable vector!
    constructN :: forall (v :: * -> *) a. Vector v a => Int -> (v a -> a) -> v a
    constructN !Int
    n v a -> a
    f = (forall s. ST s (v a)) -> v a
    forall a. (forall s. ST s a) -> a
    runST (
      do
        v  <- Int -> ST s (Mutable v (PrimState (ST s)) a)
    forall (m :: * -> *) (v :: * -> * -> *) a.
    (HasCallStack, PrimMonad m, MVector v a) =>
    Int -> m (v (PrimState m) a)
    M.new Int
    n
        v' <- unsafeFreeze v
        fill v' 0
      )
      where
        fill :: forall s. v a -> Int -> ST s (v a)
        fill :: forall s. v a -> Int -> ST s (v a)
    fill !v a
    v Int
    i | Int
    i Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    n = let x :: a
    x = v a -> a
    f (Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
    unsafeTake Int
    i v a
    v)
                            in v a -> a -> ST s (v a) -> ST s (v a)
    forall b. v a -> a -> b -> b
    forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
    elemseq v a
    v a
    x (ST s (v a) -> ST s (v a)) -> ST s (v a) -> ST s (v a)
    forall a b. (a -> b) -> a -> b
    $ do
                              v'  <- v a -> ST s (Mutable v (PrimState (ST s)) a)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    v a -> m (Mutable v (PrimState m) a)
    unsafeThaw v a
    v
                              M.unsafeWrite v' i x
                              v'' <- unsafeFreeze v'
                              fill v'' (i+1)
        fill v a
    v Int
    _ = v a -> ST s (v a)
    forall a. a -> ST s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return v a
    v

    -- | /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>
    constructrN :: forall v a. Vector v a => Int -> (v a -> a) -> v a
    {-# INLINE constructrN #-}
    -- NOTE: We *CANNOT* wrap this in New and then fuse because the elements
    -- might contain references to the immutable vector!
    constructrN :: forall (v :: * -> *) a. Vector v a => Int -> (v a -> a) -> v a
    constructrN !Int
    n v a -> a
    f = (forall s. ST s (v a)) -> v a
    forall a. (forall s. ST s a) -> a
    runST (
      do
        v  <- Int
    n Int -> ST s (Mutable v s a) -> ST s (Mutable v s a)
    forall a b. a -> b -> b
    `seq` Int -> ST s (Mutable v (PrimState (ST s)) a)
    forall (m :: * -> *) (v :: * -> * -> *) a.
    (HasCallStack, PrimMonad m, MVector v a) =>
    Int -> m (v (PrimState m) a)
    M.new Int
    n
        v' <- unsafeFreeze v
        fill v' 0
      )
      where
        fill :: forall s. v a -> Int -> ST s (v a)
        fill :: forall s. v a -> Int -> ST s (v a)
    fill !v a
    v Int
    i | Int
    i Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    n = let x :: a
    x = v a -> a
    f (Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice (Int
    nInt -> Int -> Int
    forall a. Num a => a -> a -> a
    -Int
    i) Int
    i v a
    v)
                            in v a -> a -> ST s (v a) -> ST s (v a)
    forall b. v a -> a -> b -> b
    forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
    elemseq v a
    v a
    x (ST s (v a) -> ST s (v a)) -> ST s (v a) -> ST s (v a)
    forall a b. (a -> b) -> a -> b
    $ do
                              v'  <- v a -> ST s (Mutable v (PrimState (ST s)) a)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    v a -> m (Mutable v (PrimState m) a)
    unsafeThaw v a
    v
                              M.unsafeWrite v' (n-i-1) x
                              v'' <- unsafeFreeze v'
                              fill v'' (i+1)
        fill v a
    v Int
    _ = v a -> ST s (v a)
    forall a. a -> ST s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return v a
    v

    -- 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>
    enumFromN :: (Vector v a, Num a) => a -> Int -> v a
    {-# INLINE enumFromN #-}
    enumFromN :: forall (v :: * -> *) a. (Vector v a, Num a) => a -> Int -> v a
    enumFromN a
    x Int
    n = a -> a -> Int -> v a
    forall (v :: * -> *) a. (Vector v a, Num a) => a -> a -> Int -> v a
    enumFromStepN a
    x a
    1 Int
    n

    -- | /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>
    enumFromStepN :: forall v a. (Vector v a, Num a) => a -> a -> Int -> v a
    {-# INLINE enumFromStepN #-}
    enumFromStepN :: forall (v :: * -> *) a. (Vector v a, Num a) => a -> a -> Int -> v a
    enumFromStepN a
    x a
    y Int
    n = v a -> a -> v a -> v a
    forall b. v a -> a -> b -> b
    forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
    elemseq (v a
    forall a. HasCallStack => a
    undefined :: v a) a
    x
                        (v a -> v a) -> v a -> v a
    forall a b. (a -> b) -> a -> b
    $ v a -> a -> v a -> v a
    forall b. v a -> a -> b -> b
    forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
    elemseq (v a
    forall a. HasCallStack => a
    undefined :: v a) a
    y
                        (v a -> v a) -> v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
                        (Bundle v a -> v a) -> Bundle v a -> v a
    forall a b. (a -> b) -> a -> b
    $ a -> a -> Int -> Bundle v a
    forall a (v :: * -> *). Num a => a -> a -> Int -> Bundle v a
    Bundle.enumFromStepN  a
    x a
    y Int
    n

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

    -- | /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.
    enumFromThenTo :: (Vector v a, Enum a) => a -> a -> a -> v a
    {-# INLINE enumFromThenTo #-}
    enumFromThenTo :: forall (v :: * -> *) a. (Vector v a, Enum a) => a -> a -> a -> v a
    enumFromThenTo a
    x a
    y a
    z = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (a -> a -> a -> Bundle v a
    forall a (v :: * -> *). Enum a => a -> a -> a -> Bundle v a
    Bundle.enumFromThenTo a
    x a
    y a
    z)

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

    -- | /O(n)/ Prepend an element.
    cons :: forall v a. Vector v a => a -> v a -> v a
    {-# INLINE cons #-}
    cons :: forall (v :: * -> *) a. Vector v a => a -> v a -> v a
    cons a
    x v a
    v = v a -> a -> v a -> v a
    forall b. v a -> a -> b -> b
    forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
    elemseq (v a
    forall a. HasCallStack => a
    undefined :: v a) a
    x
             (v a -> v a) -> v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
             (Bundle v a -> v a) -> Bundle v a -> v a
    forall a b. (a -> b) -> a -> b
    $ a -> Bundle v a -> Bundle v a
    forall a (v :: * -> *). a -> Bundle v a -> Bundle v a
    Bundle.cons a
    x
             (Bundle v a -> Bundle v a) -> Bundle v a -> Bundle v a
    forall a b. (a -> b) -> a -> b
    $ v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    v

    -- | /O(n)/ Append an element.
    snoc :: forall v a. Vector v a => v a -> a -> v a
    {-# INLINE snoc #-}
    snoc :: forall (v :: * -> *) a. Vector v a => v a -> a -> v a
    snoc v a
    v a
    x = v a -> a -> v a -> v a
    forall b. v a -> a -> b -> b
    forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
    elemseq (v a
    forall a. HasCallStack => a
    undefined :: v a) a
    x
             (v a -> v a) -> v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
             (Bundle v a -> v a) -> Bundle v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Bundle v a -> a -> Bundle v a
    forall (v :: * -> *) a. Bundle v a -> a -> Bundle v a
    Bundle.snoc (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    v) a
    x

    infixr 5 ++
    -- | /O(m+n)/ Concatenate two vectors.
    (++) :: Vector v a => v a -> v a -> v a
    {-# INLINE (++) #-}
    v a
    v ++ :: forall (v :: * -> *) a. Vector v a => v a -> v a -> v a
    ++ v a
    w = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    v Bundle v a -> Bundle v a -> Bundle v a
    forall (v :: * -> *) a. Bundle v a -> Bundle v a -> Bundle v a
    Bundle.++ v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    w)

    -- | /O(n)/ Concatenate all vectors in the list.
    concat :: Vector v a => [v a] -> v a
    {-# INLINE concat #-}
    concat :: forall (v :: * -> *) a. Vector v a => [v a] -> v a
    concat = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> ([v a] -> Bundle v a) -> [v a] -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [v a] -> Bundle v a
    forall (v :: * -> *) a. Vector v a => [v a] -> Bundle v a
    Bundle.fromVectors
    {-
    concat vs = unstream (Bundle.flatten mk step (Exact n) (Bundle.fromList vs))
      where
        n = List.foldl' (\k v -> k + length v) 0 vs

        {-# INLINE_INNER step #-}
        step (v,i,k)
          | i < k = case unsafeIndexM v i of
                      Box x -> Bundle.Yield x (v,i+1,k)
          | otherwise = Bundle.Done

        {-# INLINE mk #-}
        mk v = let k = length v
               in
               k `seq` (v,0,k)
    -}

    -- | /O(n)/ Concatenate all vectors in the non-empty list.
    concatNE :: Vector v a => NonEmpty.NonEmpty (v a) -> v a
    concatNE :: forall (v :: * -> *) a. Vector v a => NonEmpty (v a) -> v a
    concatNE = [v a] -> v a
    forall (v :: * -> *) a. Vector v a => [v a] -> v a
    concat ([v a] -> v a)
    -> (NonEmpty (v a) -> [v a]) -> NonEmpty (v a) -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NonEmpty (v a) -> [v a]
    forall a. NonEmpty a -> [a]
    NonEmpty.toList

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

    -- | /O(n)/ Execute the monadic action the given number of times and store the
    -- results in a vector.
    replicateM :: (Monad m, Vector v a) => Int -> m a -> m (v a)
    {-# INLINE replicateM #-}
    replicateM :: forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    Int -> m a -> m (v a)
    replicateM Int
    n m a
    m = MBundle m (ZonkAny 6) a -> m (v a)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (Int -> m a -> MBundle m (ZonkAny 6) a
    forall (m :: * -> *) a (v :: * -> *).
    Monad m =>
    Int -> m a -> Bundle m v a
    MBundle.replicateM Int
    n m a
    m)

    -- | /O(n)/ Construct a vector of the given length by applying the monadic
    -- action to each index.
    generateM :: (Monad m, Vector v a) => Int -> (Int -> m a) -> m (v a)
    {-# INLINE generateM #-}
    generateM :: forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    Int -> (Int -> m a) -> m (v a)
    generateM Int
    n Int -> m a
    f = MBundle m (ZonkAny 5) a -> m (v a)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (Int -> (Int -> m a) -> MBundle m (ZonkAny 5) a
    forall (m :: * -> *) a (v :: * -> *).
    Monad m =>
    Int -> (Int -> m a) -> Bundle m v a
    MBundle.generateM Int
    n Int -> m a
    f)

    -- | /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.12.0.0
    iterateNM :: (Monad m, Vector v a) => Int -> (a -> m a) -> a -> m (v a)
    {-# INLINE iterateNM #-}
    iterateNM :: forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    Int -> (a -> m a) -> a -> m (v a)
    iterateNM Int
    n a -> m a
    f a
    x = MBundle m (ZonkAny 4) a -> m (v a)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (Int -> (a -> m a) -> a -> MBundle m (ZonkAny 4) a
    forall (m :: * -> *) a (u :: * -> *).
    Monad m =>
    Int -> (a -> m a) -> a -> Bundle m u a
    MBundle.iterateNM Int
    n a -> m a
    f a
    x)

    -- | Execute the monadic action and freeze the resulting vector.
    --
    -- @
    -- create (do { v \<- 'M.new' 2; 'M.write' v 0 \'a\'; 'M.write' v 1 \'b\'; return v }) = \<'a','b'\>
    -- @
    create :: Vector v a => (forall s. ST s (Mutable v s a)) -> v a
    {-# INLINE create #-}
    create :: forall (v :: * -> *) a.
    Vector v a =>
    (forall s. ST s (Mutable v s a)) -> v a
    create forall s. ST s (Mutable v s a)
    p = New v a -> v a
    forall (v :: * -> *) a. Vector v a => New v a -> v a
    new ((forall s. ST s (Mutable v s a)) -> New v a
    forall (v :: * -> *) a. (forall s. ST s (Mutable v s a)) -> New v a
    New.create ST s (Mutable v s a)
    forall s. ST s (Mutable v s a)
    p)

    -- | Execute the monadic action and freeze the resulting vectors.
    createT
      :: (T.Traversable f, Vector v a)
      => (forall s. ST s (f (Mutable v s a))) -> f (v a)
    {-# INLINE createT #-}
    createT :: forall (f :: * -> *) (v :: * -> *) a.
    (Traversable f, Vector v a) =>
    (forall s. ST s (f (Mutable v s a))) -> f (v a)
    createT forall s. ST s (f (Mutable v s a))
    p = (forall s. ST s (f (v a))) -> f (v a)
    forall a. (forall s. ST s a) -> a
    runST (ST s (f (Mutable v s a))
    forall s. ST s (f (Mutable v s a))
    p ST s (f (Mutable v s a))
    -> (f (Mutable v s a) -> ST s (f (v a))) -> ST s (f (v a))
    forall a b. ST s a -> (a -> ST s b) -> ST s b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (Mutable v s a -> ST s (v a))
    -> f (Mutable v s a) -> ST s (f (v a))
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> f a -> m (f b)
    T.mapM Mutable v s a -> ST s (v a)
    Mutable v (PrimState (ST s)) a -> ST s (v a)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m (v a)
    unsafeFreeze)

    -- 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.
    force :: Vector v a => v a -> v a
    -- FIXME: we probably ought to inline this later as the rules still might fire
    -- otherwise
    {-# INLINE_FUSED force #-}
    force :: forall (v :: * -> *) a. Vector v a => v a -> v a
    force v a
    v = New v a -> v a
    forall (v :: * -> *) a. Vector v a => New v a -> v a
    new (v a -> New v a
    forall (v :: * -> *) a. Vector v a => v a -> New v a
    clone v a
    v)

    -- 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>
    --
    (//) :: Vector v a => v a        -- ^ initial vector (of length @m@)
                       -> [(Int, a)] -- ^ list of index/value pairs (of length @n@)
                       -> v a
    {-# INLINE (//) #-}
    v a
    v // :: forall (v :: * -> *) a. Vector v a => v a -> [(Int, a)] -> v a
    // [(Int, a)]
    us = v a -> Bundle (ZonkAny 3) (Int, a) -> v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u (Int, a) -> v a
    update_stream v a
    v ([(Int, a)] -> Bundle (ZonkAny 3) (Int, a)
    forall a (v :: * -> *). [a] -> Bundle v a
    Bundle.fromList [(Int, a)]
    us)

    -- | /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>
    --
    update :: (Vector v a, Vector v (Int, a))
            => v a        -- ^ initial vector (of length @m@)
            -> v (Int, a) -- ^ vector of index/value pairs (of length @n@)
            -> v a
    {-# INLINE update #-}
    update :: forall (v :: * -> *) a.
    (Vector v a, Vector v (Int, a)) =>
    v a -> v (Int, a) -> v a
    update v a
    v v (Int, a)
    w = v a -> Bundle v (Int, a) -> v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u (Int, a) -> v a
    update_stream v a
    v (v (Int, a) -> Bundle v (Int, a)
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v (Int, a)
    w)

    -- | /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>
    --
    -- This function is useful for instances of 'Vector' that cannot store pairs.
    -- Otherwise, 'update' is probably more convenient.
    --
    -- @
    -- update_ xs is ys = 'update' xs ('zip' is ys)
    -- @
    update_ :: (Vector v a, Vector v Int)
            => v a   -- ^ initial vector (of length @m@)
            -> v Int -- ^ index vector (of length @n1@)
            -> v a   -- ^ value vector (of length @n2@)
            -> v a
    {-# INLINE update_ #-}
    update_ :: forall (v :: * -> *) a.
    (Vector v a, Vector v Int) =>
    v a -> v Int -> v a -> v a
    update_ v a
    v v Int
    is v a
    w = v a -> Bundle v (Int, a) -> v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u (Int, a) -> v a
    update_stream v a
    v ((Int -> a -> (Int, a))
    -> Bundle v Int -> Bundle v a -> Bundle v (Int, a)
    forall a b c (v :: * -> *).
    (a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
    Bundle.zipWith (,) (v Int -> Bundle v Int
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v Int
    is) (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    w))

    update_stream :: Vector v a => v a -> Bundle u (Int,a) -> v a
    {-# INLINE update_stream #-}
    update_stream :: forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u (Int, a) -> v a
    update_stream = (forall s. Mutable v s a -> Bundle u (Int, a) -> ST s ())
    -> v a -> Bundle u (Int, a) -> v a
    forall (v :: * -> *) a (u :: * -> *) b.
    Vector v a =>
    (forall s. Mutable v s a -> Bundle u b -> ST s ())
    -> v a -> Bundle u b -> v a
    modifyWithBundle Mutable v s a -> Bundle u (Int, a) -> ST s ()
    Mutable v (PrimState (ST s)) a -> Bundle u (Int, a) -> ST s ()
    forall s. Mutable v s a -> Bundle u (Int, a) -> ST s ()
    forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *).
    (HasCallStack, PrimMonad m, MVector v a) =>
    v (PrimState m) a -> Bundle u (Int, a) -> m ()
    M.update

    -- | Same as ('//'), but without bounds checking.
    unsafeUpd :: Vector v a => v a -> [(Int, a)] -> v a
    {-# INLINE unsafeUpd #-}
    unsafeUpd :: forall (v :: * -> *) a. Vector v a => v a -> [(Int, a)] -> v a
    unsafeUpd v a
    v [(Int, a)]
    us = v a -> Bundle (ZonkAny 2) (Int, a) -> v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u (Int, a) -> v a
    unsafeUpdate_stream v a
    v ([(Int, a)] -> Bundle (ZonkAny 2) (Int, a)
    forall a (v :: * -> *). [a] -> Bundle v a
    Bundle.fromList [(Int, a)]
    us)

    -- | Same as 'update', but without bounds checking.
    unsafeUpdate :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) -> v a
    {-# INLINE unsafeUpdate #-}
    unsafeUpdate :: forall (v :: * -> *) a.
    (Vector v a, Vector v (Int, a)) =>
    v a -> v (Int, a) -> v a
    unsafeUpdate v a
    v v (Int, a)
    w = v a -> Bundle v (Int, a) -> v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u (Int, a) -> v a
    unsafeUpdate_stream v a
    v (v (Int, a) -> Bundle v (Int, a)
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v (Int, a)
    w)

    -- | Same as 'update_', but without bounds checking.
    unsafeUpdate_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a
    {-# INLINE unsafeUpdate_ #-}
    unsafeUpdate_ :: forall (v :: * -> *) a.
    (Vector v a, Vector v Int) =>
    v a -> v Int -> v a -> v a
    unsafeUpdate_ v a
    v v Int
    is v a
    w
      = v a -> Bundle v (Int, a) -> v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u (Int, a) -> v a
    unsafeUpdate_stream v a
    v ((Int -> a -> (Int, a))
    -> Bundle v Int -> Bundle v a -> Bundle v (Int, a)
    forall a b c (v :: * -> *).
    (a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
    Bundle.zipWith (,) (v Int -> Bundle v Int
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v Int
    is) (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    w))

    unsafeUpdate_stream :: Vector v a => v a -> Bundle u (Int,a) -> v a
    {-# INLINE unsafeUpdate_stream #-}
    unsafeUpdate_stream :: forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u (Int, a) -> v a
    unsafeUpdate_stream = (forall s. Mutable v s a -> Bundle u (Int, a) -> ST s ())
    -> v a -> Bundle u (Int, a) -> v a
    forall (v :: * -> *) a (u :: * -> *) b.
    Vector v a =>
    (forall s. Mutable v s a -> Bundle u b -> ST s ())
    -> v a -> Bundle u b -> v a
    modifyWithBundle Mutable v s a -> Bundle u (Int, a) -> ST s ()
    Mutable v (PrimState (ST s)) a -> Bundle u (Int, a) -> ST s ()
    forall s. Mutable v s a -> Bundle u (Int, a) -> ST s ()
    forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *).
    (PrimMonad m, MVector v a) =>
    v (PrimState m) a -> Bundle u (Int, a) -> m ()
    M.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.Strict as V
    -- >>> V.accum (+) (V.fromList [1000,2000,3000]) [(2,4),(1,6),(0,3),(1,10)]
    -- [1003,2016,3004]
    accum :: Vector v a
          => (a -> b -> a) -- ^ accumulating function @f@
          -> v a           -- ^ initial vector (of length @m@)
          -> [(Int,b)]     -- ^ list of index/value pairs (of length @n@)
          -> v a
    {-# INLINE accum #-}
    accum :: forall (v :: * -> *) a b.
    Vector v a =>
    (a -> b -> a) -> v a -> [(Int, b)] -> v a
    accum a -> b -> a
    f v a
    v [(Int, b)]
    us = (a -> b -> a) -> v a -> Bundle (ZonkAny 1) (Int, b) -> v a
    forall (v :: * -> *) a b (u :: * -> *).
    Vector v a =>
    (a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
    accum_stream a -> b -> a
    f v a
    v ([(Int, b)] -> Bundle (ZonkAny 1) (Int, b)
    forall a (v :: * -> *). [a] -> Bundle v a
    Bundle.fromList [(Int, b)]
    us)

    -- | /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.Strict as V
    -- >>> V.accumulate (+) (V.fromList [1000,2000,3000]) (V.fromList [(2,4),(1,6),(0,3),(1,10)])
    -- [1003,2016,3004]
    accumulate :: (Vector v a, Vector v (Int, b))
               => (a -> b -> a) -- ^ accumulating function @f@
               -> v a           -- ^ initial vector (of length @m@)
               -> v (Int,b)     -- ^ vector of index/value pairs (of length @n@)
               -> v a
    {-# INLINE accumulate #-}
    accumulate :: forall (v :: * -> *) a b.
    (Vector v a, Vector v (Int, b)) =>
    (a -> b -> a) -> v a -> v (Int, b) -> v a
    accumulate a -> b -> a
    f v a
    v v (Int, b)
    us = (a -> b -> a) -> v a -> Bundle v (Int, b) -> v a
    forall (v :: * -> *) a b (u :: * -> *).
    Vector v a =>
    (a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
    accum_stream a -> b -> a
    f v a
    v (v (Int, b) -> Bundle v (Int, b)
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v (Int, b)
    us)

    -- | /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>
    --
    -- This function is useful for instances of 'Vector' that cannot store pairs.
    -- Otherwise, 'accumulate' is probably more convenient:
    --
    -- @
    -- accumulate_ f as is bs = 'accumulate' f as ('zip' is bs)
    -- @
    accumulate_ :: (Vector v a, Vector v Int, Vector v b)
                    => (a -> b -> a) -- ^ accumulating function @f@
                    -> v a           -- ^ initial vector (of length @m@)
                    -> v Int         -- ^ index vector (of length @n1@)
                    -> v b           -- ^ value vector (of length @n2@)
                    -> v a
    {-# INLINE accumulate_ #-}
    accumulate_ :: forall (v :: * -> *) a b.
    (Vector v a, Vector v Int, Vector v b) =>
    (a -> b -> a) -> v a -> v Int -> v b -> v a
    accumulate_ a -> b -> a
    f v a
    v v Int
    is v b
    xs = (a -> b -> a) -> v a -> Bundle v (Int, b) -> v a
    forall (v :: * -> *) a b (u :: * -> *).
    Vector v a =>
    (a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
    accum_stream a -> b -> a
    f v a
    v ((Int -> b -> (Int, b))
    -> Bundle v Int -> Bundle v b -> Bundle v (Int, b)
    forall a b c (v :: * -> *).
    (a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
    Bundle.zipWith (,) (v Int -> Bundle v Int
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v Int
    is)
                                                                 (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    xs))

    accum_stream :: Vector v a => (a -> b -> a) -> v a -> Bundle u (Int,b) -> v a
    {-# INLINE accum_stream #-}
    accum_stream :: forall (v :: * -> *) a b (u :: * -> *).
    Vector v a =>
    (a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
    accum_stream a -> b -> a
    f = (forall s. Mutable v s a -> Bundle u (Int, b) -> ST s ())
    -> v a -> Bundle u (Int, b) -> v a
    forall (v :: * -> *) a (u :: * -> *) b.
    Vector v a =>
    (forall s. Mutable v s a -> Bundle u b -> ST s ())
    -> v a -> Bundle u b -> v a
    modifyWithBundle ((a -> b -> a)
    -> Mutable v (PrimState (ST s)) a -> Bundle u (Int, b) -> ST s ()
    forall (m :: * -> *) (v :: * -> * -> *) a b (u :: * -> *).
    (HasCallStack, PrimMonad m, MVector v a) =>
    (a -> b -> a) -> v (PrimState m) a -> Bundle u (Int, b) -> m ()
    M.accum a -> b -> a
    f)

    -- | Same as 'accum', but without bounds checking.
    unsafeAccum :: Vector v a => (a -> b -> a) -> v a -> [(Int,b)] -> v a
    {-# INLINE unsafeAccum #-}
    unsafeAccum :: forall (v :: * -> *) a b.
    Vector v a =>
    (a -> b -> a) -> v a -> [(Int, b)] -> v a
    unsafeAccum a -> b -> a
    f v a
    v [(Int, b)]
    us = (a -> b -> a) -> v a -> Bundle (ZonkAny 0) (Int, b) -> v a
    forall (v :: * -> *) a b (u :: * -> *).
    Vector v a =>
    (a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
    unsafeAccum_stream a -> b -> a
    f v a
    v ([(Int, b)] -> Bundle (ZonkAny 0) (Int, b)
    forall a (v :: * -> *). [a] -> Bundle v a
    Bundle.fromList [(Int, b)]
    us)

    -- | Same as 'accumulate', but without bounds checking.
    unsafeAccumulate :: (Vector v a, Vector v (Int, b))
                    => (a -> b -> a) -> v a -> v (Int,b) -> v a
    {-# INLINE unsafeAccumulate #-}
    unsafeAccumulate :: forall (v :: * -> *) a b.
    (Vector v a, Vector v (Int, b)) =>
    (a -> b -> a) -> v a -> v (Int, b) -> v a
    unsafeAccumulate a -> b -> a
    f v a
    v v (Int, b)
    us = (a -> b -> a) -> v a -> Bundle v (Int, b) -> v a
    forall (v :: * -> *) a b (u :: * -> *).
    Vector v a =>
    (a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
    unsafeAccum_stream a -> b -> a
    f v a
    v (v (Int, b) -> Bundle v (Int, b)
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v (Int, b)
    us)

    -- | Same as 'accumulate_', but without bounds checking.
    unsafeAccumulate_ :: (Vector v a, Vector v Int, Vector v b)
                    => (a -> b -> a) -> v a -> v Int -> v b -> v a
    {-# INLINE unsafeAccumulate_ #-}
    unsafeAccumulate_ :: forall (v :: * -> *) a b.
    (Vector v a, Vector v Int, Vector v b) =>
    (a -> b -> a) -> v a -> v Int -> v b -> v a
    unsafeAccumulate_ a -> b -> a
    f v a
    v v Int
    is v b
    xs
      = (a -> b -> a) -> v a -> Bundle v (Int, b) -> v a
    forall (v :: * -> *) a b (u :: * -> *).
    Vector v a =>
    (a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
    unsafeAccum_stream a -> b -> a
    f v a
    v ((Int -> b -> (Int, b))
    -> Bundle v Int -> Bundle v b -> Bundle v (Int, b)
    forall a b c (v :: * -> *).
    (a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
    Bundle.zipWith (,) (v Int -> Bundle v Int
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v Int
    is) (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    xs))

    unsafeAccum_stream
      :: Vector v a => (a -> b -> a) -> v a -> Bundle u (Int,b) -> v a
    {-# INLINE unsafeAccum_stream #-}
    unsafeAccum_stream :: forall (v :: * -> *) a b (u :: * -> *).
    Vector v a =>
    (a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
    unsafeAccum_stream a -> b -> a
    f = (forall s. Mutable v s a -> Bundle u (Int, b) -> ST s ())
    -> v a -> Bundle u (Int, b) -> v a
    forall (v :: * -> *) a (u :: * -> *) b.
    Vector v a =>
    (forall s. Mutable v s a -> Bundle u b -> ST s ())
    -> v a -> Bundle u b -> v a
    modifyWithBundle ((a -> b -> a)
    -> Mutable v (PrimState (ST s)) a -> Bundle u (Int, b) -> ST s ()
    forall (m :: * -> *) (v :: * -> * -> *) a b (u :: * -> *).
    (PrimMonad m, MVector v a) =>
    (a -> b -> a) -> v (PrimState m) a -> Bundle u (Int, b) -> m ()
    M.unsafeAccum a -> b -> a
    f)

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

    -- | /O(n)/ Reverse a vector.
    reverse :: (Vector v a) => v a -> v a
    {-# INLINE reverse #-}
    -- FIXME: make this fuse better, add support for recycling
    reverse :: forall (v :: * -> *) a. Vector v a => v a -> v a
    reverse = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR

    -- | /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>
    backpermute :: forall v a. (HasCallStack, Vector v a, Vector v Int)
                => v a   -- ^ @xs@ value vector
                -> v Int -- ^ @is@ index vector (of length @n@)
                -> v a
    {-# INLINE backpermute #-}
    -- This somewhat non-intuitive definition ensures that the resulting vector
    -- does not retain references to the original one even if it is lazy in its
    -- elements. This would not be the case if we simply used map (v!)
    backpermute :: forall (v :: * -> *) a.
    (HasCallStack, Vector v a, Vector v Int) =>
    v a -> v Int -> v a
    backpermute v a
    v v Int
    is = v a -> v a -> v a
    forall a b. a -> b -> b
    seq v a
    v
                     (v a -> v a) -> v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Int -> v a -> v a
    forall a b. a -> b -> b
    seq Int
    n
                     (v a -> v a) -> v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
                     (Bundle v a -> v a) -> Bundle v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Bundle v (Box a) -> Bundle v a
    forall (v :: * -> *) a. Bundle v (Box a) -> Bundle v a
    Bundle.unbox
                     (Bundle v (Box a) -> Bundle v a) -> Bundle v (Box a) -> Bundle v a
    forall a b. (a -> b) -> a -> b
    $ (Int -> Box a) -> Bundle v Int -> Bundle v (Box a)
    forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
    Bundle.map HasCallStack => Int -> Box a
    Int -> Box a
    index
                     (Bundle v Int -> Bundle v (Box a))
    -> Bundle v Int -> Bundle v (Box a)
    forall a b. (a -> b) -> a -> b
    $ v Int -> Bundle v Int
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v Int
    is
      where
        n :: Int
    n = v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v

        {-# INLINE index #-}
        -- NOTE: we do it this way to avoid triggering LiberateCase on n in
        -- polymorphic code
        index :: HasCallStack => Int -> Box a
        index :: HasCallStack => Int -> Box a
    index !Int
    i = Checks -> Int -> Int -> Box a -> Box a
    forall a. HasCallStack => Checks -> Int -> Int -> a -> a
    checkIndex Checks
    Bounds Int
    i Int
    n (Box a -> Box a) -> Box a -> Box a
    forall a b. (a -> b) -> a -> b
    $ v a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    basicUnsafeIndexM v a
    v Int
    i

    -- | Same as 'backpermute', but without bounds checking.
    unsafeBackpermute :: (Vector v a, Vector v Int) => v a -> v Int -> v a
    {-# INLINE unsafeBackpermute #-}
    unsafeBackpermute :: forall (v :: * -> *) a.
    (Vector v a, Vector v Int) =>
    v a -> v Int -> v a
    unsafeBackpermute v a
    v v Int
    is = v a -> v a -> v a
    forall a b. a -> b -> b
    seq v a
    v
                           (v a -> v a) -> v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Int -> v a -> v a
    forall a b. a -> b -> b
    seq Int
    n
                           (v a -> v a) -> v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
                           (Bundle v a -> v a) -> Bundle v a -> v a
    forall a b. (a -> b) -> a -> b
    $ Bundle v (Box a) -> Bundle v a
    forall (v :: * -> *) a. Bundle v (Box a) -> Bundle v a
    Bundle.unbox
                           (Bundle v (Box a) -> Bundle v a) -> Bundle v (Box a) -> Bundle v a
    forall a b. (a -> b) -> a -> b
    $ (Int -> Box a) -> Bundle v Int -> Bundle v (Box a)
    forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
    Bundle.map Int -> Box a
    index
                           (Bundle v Int -> Bundle v (Box a))
    -> Bundle v Int -> Bundle v (Box a)
    forall a b. (a -> b) -> a -> b
    $ v Int -> Bundle v Int
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v Int
    is
      where
        n :: Int
    n = v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v

        {-# INLINE index #-}
        -- NOTE: we do it this way to avoid triggering LiberateCase on n in
        -- polymorphic code
        index :: Int -> Box a
    index !Int
    i = Checks -> Int -> Int -> Box a -> Box a
    forall a. HasCallStack => Checks -> Int -> Int -> a -> a
    checkIndex Checks
    Unsafe Int
    i Int
    n (Box a -> Box a) -> Box a -> Box a
    forall a b. (a -> b) -> a -> b
    $ v a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    basicUnsafeIndexM v a
    v Int
    i

    -- 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.Strict as V
    -- >>> import qualified Data.Vector.Strict.Mutable as MV
    -- >>> V.modify (\v -> MV.write v 0 'x') $ V.replicate 4 'a'
    -- "xaaa"
    modify :: Vector v a => (forall s. Mutable v s a -> ST s ()) -> v a -> v a
    {-# INLINE modify #-}
    modify :: forall (v :: * -> *) a.
    Vector v a =>
    (forall s. Mutable v s a -> ST s ()) -> v a -> v a
    modify forall s. Mutable v s a -> ST s ()
    p = New v a -> v a
    forall (v :: * -> *) a. Vector v a => New v a -> v a
    new (New v a -> v a) -> (v a -> New v a) -> v a -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall s. Mutable v s a -> ST s ()) -> New v a -> New v a
    forall (v :: * -> *) a.
    (forall s. Mutable v s a -> ST s ()) -> New v a -> New v a
    New.modify Mutable v s a -> ST s ()
    forall s. Mutable v s a -> ST s ()
    p (New v a -> New v a) -> (v a -> New v a) -> v a -> New v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> New v a
    forall (v :: * -> *) a. Vector v a => v a -> New v a
    clone

    -- We have to make sure that this is strict in the stream but we can't seq on
    -- it while fusion is happening. Hence this ugliness.
    modifyWithBundle :: Vector v a
                     => (forall s. Mutable v s a -> Bundle u b -> ST s ())
                     -> v a -> Bundle u b -> v a
    {-# INLINE modifyWithBundle #-}
    modifyWithBundle :: forall (v :: * -> *) a (u :: * -> *) b.
    Vector v a =>
    (forall s. Mutable v s a -> Bundle u b -> ST s ())
    -> v a -> Bundle u b -> v a
    modifyWithBundle forall s. Mutable v s a -> Bundle u b -> ST s ()
    p v a
    v Bundle u b
    s = New v a -> v a
    forall (v :: * -> *) a. Vector v a => New v a -> v a
    new ((forall s. Mutable v s a -> Bundle u b -> ST s ())
    -> New v a -> Bundle u b -> New v a
    forall (v :: * -> *) a (u :: * -> *) b.
    (forall s. Mutable v s a -> Bundle u b -> ST s ())
    -> New v a -> Bundle u b -> New v a
    New.modifyWithBundle Mutable v s a -> Bundle u b -> ST s ()
    forall s. Mutable v s a -> Bundle u b -> ST s ()
    p (v a -> New v a
    forall (v :: * -> *) a. Vector v a => v a -> New v a
    clone v a
    v) Bundle u b
    s)

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

    -- | /O(n)/ Pair each element in a vector with its index.
    indexed :: (Vector v a, Vector v (Int,a)) => v a -> v (Int,a)
    {-# INLINE indexed #-}
    indexed :: forall (v :: * -> *) a.
    (Vector v a, Vector v (Int, a)) =>
    v a -> v (Int, a)
    indexed = Bundle v (Int, a) -> v (Int, a)
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v (Int, a) -> v (Int, a))
    -> (v a -> Bundle v (Int, a)) -> v a -> v (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v a -> Bundle v (Int, a))
    -> (v a -> Bundle v a) -> v a -> Bundle v (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

    -- | /O(n)/ Map a function over a vector.
    map :: (Vector v a, Vector v b) => (a -> b) -> v a -> v b
    {-# INLINE map #-}
    map :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map a -> b
    f = Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> b) -> Stream m a -> Stream m b
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b) -> Stream m a -> Stream m b
    S.map a -> b
    f) Size -> Size
    forall a. a -> a
    id (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Apply a function to every element of a vector and its index.
    imap :: (Vector v a, Vector v b) => (Int -> a -> b) -> v a -> v b
    {-# INLINE imap #-}
    imap :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> b) -> v a -> v b
    imap Int -> a -> b
    f = Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace (((Int, a) -> b) -> Stream m (Int, a) -> Stream m b
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b) -> Stream m a -> Stream m b
    S.map ((Int -> a -> b) -> (Int, a) -> b
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b
    f) (Stream m (Int, a) -> Stream m b)
    -> (Stream m a -> Stream m (Int, a)) -> Stream m a -> Stream m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Stream m a -> Stream m (Int, a)
    forall (m :: * -> *) a. Monad m => Stream m a -> Stream m (Int, a)
    S.indexed) Size -> Size
    forall a. a -> a
    id
                      (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | Map a function over a vector and concatenate the results.
    concatMap :: (Vector v a, Vector v b) => (a -> v b) -> v a -> v b
    {-# INLINE concatMap #-}
    -- NOTE: We can't fuse concatMap anyway so don't pretend we do.
    -- This seems to be slightly slower
    -- concatMap f = concat . Bundle.toList . Bundle.map f . stream

    -- Slowest
    -- concatMap f = unstream . Bundle.concatMap (stream . f) . stream

    -- Used to be fastest
    {-
    concatMap f = unstream
                . Bundle.flatten mk step Unknown
                . stream
      where
        {-# INLINE_INNER step #-}
        step (v,i,k)
          | i < k = case unsafeIndexM v i of
                      Box x -> Bundle.Yield x (v,i+1,k)
          | otherwise = Bundle.Done

        {-# INLINE mk #-}
        mk x = let v = f x
                   k = length v
               in
               k `seq` (v,0,k)
    -}

    -- This seems to be fastest now
    concatMap :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> v b) -> v a -> v b
    concatMap a -> v b
    f = Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
                (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v (v b) -> Bundle v b
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    Bundle u (v a) -> Bundle v a
    Bundle.concatVectors
                (Bundle v (v b) -> Bundle v b)
    -> (v a -> Bundle v (v b)) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> v b) -> Bundle v a -> Bundle v (v b)
    forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
    Bundle.map a -> v b
    f
                (Bundle v a -> Bundle v (v b))
    -> (v a -> Bundle v a) -> v a -> Bundle v (v b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

    -- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a
    -- vector of results.
    mapM :: (Monad m, Vector v a, Vector v b) => (a -> m b) -> v a -> m (v b)
    {-# INLINE mapM #-}
    mapM :: forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a, Vector v b) =>
    (a -> m b) -> v a -> m (v b)
    mapM a -> m b
    f = MBundle m v b -> m (v b)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (MBundle m v b -> m (v b))
    -> (v a -> MBundle m v b) -> v a -> m (v b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> m b) -> Bundle v a -> MBundle m v b
    forall (m :: * -> *) a b (v :: * -> *).
    Monad m =>
    (a -> m b) -> Bundle v a -> Bundle m v b
    Bundle.mapM a -> m b
    f (Bundle v a -> MBundle m v b)
    -> (v a -> Bundle v a) -> v a -> MBundle m v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Apply the monadic action to every element of a vector and its
    -- index, yielding a vector of results.
    imapM :: (Monad m, Vector v a, Vector v b)
          => (Int -> a -> m b) -> v a -> m (v b)
    imapM :: forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a, Vector v b) =>
    (Int -> a -> m b) -> v a -> m (v b)
    imapM Int -> a -> m b
    f = MBundle m v b -> m (v b)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (MBundle m v b -> m (v b))
    -> (v a -> MBundle m v b) -> v a -> m (v b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((Int, a) -> m b) -> Bundle v (Int, a) -> MBundle m v b
    forall (m :: * -> *) a b (v :: * -> *).
    Monad m =>
    (a -> m b) -> Bundle v a -> Bundle m v b
    Bundle.mapM ((Int -> a -> m b) -> (Int, a) -> m b
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> m b
    f) (Bundle v (Int, a) -> MBundle m v b)
    -> (v a -> Bundle v (Int, a)) -> v a -> MBundle m v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v a -> Bundle v (Int, a))
    -> (v a -> Bundle v a) -> v a -> Bundle v (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

    -- | /O(n)/ Apply the monadic action to every element of a vector and its
    -- index, ignoring the results.
    imapM_ :: (Monad m, Vector v a) => (Int -> a -> m b) -> v a -> m ()
    {-# INLINE imapM_ #-}
    imapM_ :: forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    (Int -> a -> m b) -> v a -> m ()
    imapM_ Int -> a -> m b
    f = ((Int, a) -> m b) -> Bundle v (Int, a) -> m ()
    forall (m :: * -> *) a b (v :: * -> *).
    Monad m =>
    (a -> m b) -> Bundle v a -> m ()
    Bundle.mapM_ ((Int -> a -> m b) -> (Int, a) -> m b
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> m b
    f) (Bundle v (Int, a) -> m ())
    -> (v a -> Bundle v (Int, a)) -> v a -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v a -> Bundle v (Int, a))
    -> (v a -> Bundle v a) -> v a -> Bundle v (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

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

    -- | /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.12.2.0
    iforM :: (Monad m, Vector v a, Vector v b) => v a -> (Int -> a -> m b) -> m (v b)
    {-# INLINE iforM #-}
    iforM :: forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a, Vector v b) =>
    v a -> (Int -> a -> m b) -> m (v b)
    iforM v a
    as Int -> a -> m b
    f = (Int -> a -> m b) -> v a -> m (v b)
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a, Vector v b) =>
    (Int -> a -> m b) -> v a -> m (v b)
    imapM Int -> a -> m b
    f v a
    as

    -- | /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.12.2.0
    iforM_ :: (Monad m, Vector v a) => v a -> (Int -> a -> m b) -> m ()
    {-# INLINE iforM_ #-}
    iforM_ :: forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    v a -> (Int -> a -> m b) -> m ()
    iforM_ v a
    as Int -> a -> m b
    f = (Int -> a -> m b) -> v a -> m ()
    forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a) =>
    (Int -> a -> m b) -> v a -> m ()
    imapM_ Int -> a -> m b
    f v a
    as

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

    -- | /O(min(m,n))/ Zip two vectors with the given function.
    zipWith :: (Vector v a, Vector v b, Vector v c)
            => (a -> b -> c) -> v a -> v b -> v c
    {-# INLINE zipWith #-}
    zipWith :: forall (v :: * -> *) a b c.
    (Vector v a, Vector v b, Vector v c) =>
    (a -> b -> c) -> v a -> v b -> v c
    zipWith a -> b -> c
    f = \v a
    xs v b
    ys -> Bundle v c -> v c
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream ((a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
    forall a b c (v :: * -> *).
    (a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
    Bundle.zipWith a -> b -> c
    f (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    xs) (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    ys))

    -- | Zip three vectors with the given function.
    zipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d)
             => (a -> b -> c -> d) -> v a -> v b -> v c -> v d
    {-# INLINE zipWith3 #-}
    zipWith3 :: 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
    zipWith3 a -> b -> c -> d
    f = \v a
    as v b
    bs v c
    cs -> Bundle v d -> v d
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream ((a -> b -> c -> d)
    -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d
    forall a b c d (v :: * -> *).
    (a -> b -> c -> d)
    -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d
    Bundle.zipWith3 a -> b -> c -> d
    f (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as)
                                                      (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs)
                                                      (v c -> Bundle v c
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v c
    cs))

    zipWith4 :: (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
    {-# INLINE zipWith4 #-}
    zipWith4 :: 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
    zipWith4 a -> b -> c -> d -> e
    f = \v a
    as v b
    bs v c
    cs v d
    ds ->
        Bundle v e -> v e
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream ((a -> b -> c -> d -> e)
    -> Bundle v a
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    forall a b c d e (v :: * -> *).
    (a -> b -> c -> d -> e)
    -> Bundle v a
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    Bundle.zipWith4 a -> b -> c -> d -> e
    f (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as)
                                    (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs)
                                    (v c -> Bundle v c
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v c
    cs)
                                    (v d -> Bundle v d
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v d
    ds))

    zipWith5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
                 Vector v f)
             => (a -> b -> c -> d -> e -> f) -> v a -> v b -> v c -> v d -> v e
                                             -> v f
    {-# INLINE zipWith5 #-}
    zipWith5 :: 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
    zipWith5 a -> b -> c -> d -> e -> f
    f = \v a
    as v b
    bs v c
    cs v d
    ds v e
    es ->
        Bundle v f -> v f
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream ((a -> b -> c -> d -> e -> f)
    -> Bundle v a
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    -> Bundle v f
    forall a b c d e f (v :: * -> *).
    (a -> b -> c -> d -> e -> f)
    -> Bundle v a
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    -> Bundle v f
    Bundle.zipWith5 a -> b -> c -> d -> e -> f
    f (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as)
                                    (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs)
                                    (v c -> Bundle v c
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v c
    cs)
                                    (v d -> Bundle v d
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v d
    ds)
                                    (v e -> Bundle v e
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v e
    es))

    zipWith6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
                 Vector v f, Vector v g)
             => (a -> b -> c -> d -> e -> f -> g)
             -> v a -> v b -> v c -> v d -> v e -> v f -> v g
    {-# INLINE zipWith6 #-}
    zipWith6 :: 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
    zipWith6 a -> b -> c -> d -> e -> f -> g
    f = \v a
    as v b
    bs v c
    cs v d
    ds v e
    es v f
    fs ->
        Bundle v g -> v g
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream ((a -> b -> c -> d -> e -> f -> g)
    -> Bundle v a
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    -> Bundle v f
    -> Bundle v g
    forall a b c d e f g (v :: * -> *).
    (a -> b -> c -> d -> e -> f -> g)
    -> Bundle v a
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    -> Bundle v f
    -> Bundle v g
    Bundle.zipWith6 a -> b -> c -> d -> e -> f -> g
    f (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as)
                                    (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs)
                                    (v c -> Bundle v c
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v c
    cs)
                                    (v d -> Bundle v d
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v d
    ds)
                                    (v e -> Bundle v e
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v e
    es)
                                    (v f -> Bundle v f
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v f
    fs))

    -- | /O(min(m,n))/ Zip two vectors with a function that also takes the
    -- elements' indices.
    izipWith :: (Vector v a, Vector v b, Vector v c)
            => (Int -> a -> b -> c) -> v a -> v b -> v c
    {-# INLINE izipWith #-}
    izipWith :: forall (v :: * -> *) a b c.
    (Vector v a, Vector v b, Vector v c) =>
    (Int -> a -> b -> c) -> v a -> v b -> v c
    izipWith Int -> a -> b -> c
    f = \v a
    xs v b
    ys ->
        Bundle v c -> v c
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (((Int, a) -> b -> c)
    -> Bundle v (Int, a) -> Bundle v b -> Bundle v c
    forall a b c (v :: * -> *).
    (a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
    Bundle.zipWith ((Int -> a -> b -> c) -> (Int, a) -> b -> c
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b -> c
    f) (Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    xs))
                                                             (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    ys))

    -- | Zip three vectors and their indices with the given function.
    izipWith3 :: (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
    {-# INLINE izipWith3 #-}
    izipWith3 :: 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
    izipWith3 Int -> a -> b -> c -> d
    f = \v a
    as v b
    bs v c
    cs ->
        Bundle v d -> v d
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (((Int, a) -> b -> c -> d)
    -> Bundle v (Int, a) -> Bundle v b -> Bundle v c -> Bundle v d
    forall a b c d (v :: * -> *).
    (a -> b -> c -> d)
    -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d
    Bundle.zipWith3 ((Int -> a -> b -> c -> d) -> (Int, a) -> b -> c -> d
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b -> c -> d
    f) (Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as))
                                                              (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs)
                                                              (v c -> Bundle v c
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v c
    cs))

    izipWith4 :: (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
    {-# INLINE izipWith4 #-}
    izipWith4 :: 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
    izipWith4 Int -> a -> b -> c -> d -> e
    f = \v a
    as v b
    bs v c
    cs v d
    ds ->
        Bundle v e -> v e
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (((Int, a) -> b -> c -> d -> e)
    -> Bundle v (Int, a)
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    forall a b c d e (v :: * -> *).
    (a -> b -> c -> d -> e)
    -> Bundle v a
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    Bundle.zipWith4 ((Int -> a -> b -> c -> d -> e) -> (Int, a) -> b -> c -> d -> e
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b -> c -> d -> e
    f) (Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as))
                                                              (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs)
                                                              (v c -> Bundle v c
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v c
    cs)
                                                              (v d -> Bundle v d
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v d
    ds))

    izipWith5 :: (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
    {-# INLINE izipWith5 #-}
    izipWith5 :: 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
    izipWith5 Int -> a -> b -> c -> d -> e -> f
    f = \v a
    as v b
    bs v c
    cs v d
    ds v e
    es ->
        Bundle v f -> v f
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (((Int, a) -> b -> c -> d -> e -> f)
    -> Bundle v (Int, a)
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    -> Bundle v f
    forall a b c d e f (v :: * -> *).
    (a -> b -> c -> d -> e -> f)
    -> Bundle v a
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    -> Bundle v f
    Bundle.zipWith5 ((Int -> a -> b -> c -> d -> e -> f)
    -> (Int, a) -> b -> c -> d -> e -> f
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b -> c -> d -> e -> f
    f) (Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as))
                                                              (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs)
                                                              (v c -> Bundle v c
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v c
    cs)
                                                              (v d -> Bundle v d
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v d
    ds)
                                                              (v e -> Bundle v e
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v e
    es))

    izipWith6 :: (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
    {-# INLINE izipWith6 #-}
    izipWith6 :: 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
    izipWith6 Int -> a -> b -> c -> d -> e -> f -> g
    f = \v a
    as v b
    bs v c
    cs v d
    ds v e
    es v f
    fs ->
        Bundle v g -> v g
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (((Int, a) -> b -> c -> d -> e -> f -> g)
    -> Bundle v (Int, a)
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    -> Bundle v f
    -> Bundle v g
    forall a b c d e f g (v :: * -> *).
    (a -> b -> c -> d -> e -> f -> g)
    -> Bundle v a
    -> Bundle v b
    -> Bundle v c
    -> Bundle v d
    -> Bundle v e
    -> Bundle v f
    -> Bundle v g
    Bundle.zipWith6 ((Int -> a -> b -> c -> d -> e -> f -> g)
    -> (Int, a) -> b -> c -> d -> e -> f -> g
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b -> c -> d -> e -> f -> g
    f) (Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as))
                                                              (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs)
                                                              (v c -> Bundle v c
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v c
    cs)
                                                              (v d -> Bundle v d
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v d
    ds)
                                                              (v e -> Bundle v e
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v e
    es)
                                                              (v f -> Bundle v f
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v f
    fs))

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

    -- | Zip together three vectors into a vector of triples.
    zip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c))
         => v a -> v b -> v c -> v (a, b, c)
    {-# INLINE zip3 #-}
    zip3 :: 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)
    zip3 = (a -> b -> c -> (a, b, c)) -> v a -> v b -> v c -> v (a, b, c)
    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
    zipWith3 (,,)

    zip4 :: (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)
    {-# INLINE zip4 #-}
    zip4 :: 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)
    zip4 = (a -> b -> c -> d -> (a, b, c, d))
    -> v a -> v b -> v c -> v d -> v (a, b, c, d)
    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
    zipWith4 (,,,)

    zip5 :: (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)
    {-# INLINE zip5 #-}
    zip5 :: 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)
    zip5 = (a -> b -> c -> d -> e -> (a, b, c, d, e))
    -> v a -> v b -> v c -> v d -> v e -> v (a, b, c, d, e)
    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
    zipWith5 (,,,,)

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

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

    -- | /O(min(m,n))/ Zip the two vectors with the monadic action and yield a
    -- vector of results.
    zipWithM :: (Monad m, Vector v a, Vector v b, Vector v c)
             => (a -> b -> m c) -> v a -> v b -> m (v c)
    -- FIXME: specialise for ST and IO?
    {-# INLINE zipWithM #-}
    zipWithM :: 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)
    zipWithM a -> b -> m c
    f = \v a
    as v b
    bs -> MBundle m v c -> m (v c)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (MBundle m v c -> m (v c)) -> MBundle m v c -> m (v c)
    forall a b. (a -> b) -> a -> b
    $ (a -> b -> m c) -> Bundle v a -> Bundle v b -> MBundle m v c
    forall (m :: * -> *) a b c (v :: * -> *).
    Monad m =>
    (a -> b -> m c) -> Bundle v a -> Bundle v b -> Bundle m v c
    Bundle.zipWithM a -> b -> m c
    f (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as) (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs)

    -- | /O(min(m,n))/ Zip the two vectors with a monadic action that also takes
    -- the element index and yield a vector of results.
    izipWithM :: (Monad m, Vector v a, Vector v b, Vector v c)
             => (Int -> a -> b -> m c) -> v a -> v b -> m (v c)
    {-# INLINE izipWithM #-}
    izipWithM :: 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)
    izipWithM Int -> a -> b -> m c
    m v a
    as v b
    bs = MBundle m v c -> m (v c)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (MBundle m v c -> m (v c))
    -> (Bundle v b -> MBundle m v c) -> Bundle v b -> m (v c)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((Int, a) -> b -> m c)
    -> Bundle v (Int, a) -> Bundle v b -> MBundle m v c
    forall (m :: * -> *) a b c (v :: * -> *).
    Monad m =>
    (a -> b -> m c) -> Bundle v a -> Bundle v b -> Bundle m v c
    Bundle.zipWithM ((Int -> a -> b -> m c) -> (Int, a) -> b -> m c
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b -> m c
    m)
                                    (Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as))
                                    (Bundle v b -> m (v c)) -> Bundle v b -> m (v c)
    forall a b. (a -> b) -> a -> b
    $ v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs

    -- | /O(min(m,n))/ Zip the two vectors with the monadic action and ignore the
    -- results.
    zipWithM_ :: (Monad m, Vector v a, Vector v b)
              => (a -> b -> m c) -> v a -> v b -> m ()
    {-# INLINE zipWithM_ #-}
    zipWithM_ :: forall (m :: * -> *) (v :: * -> *) a b c.
    (Monad m, Vector v a, Vector v b) =>
    (a -> b -> m c) -> v a -> v b -> m ()
    zipWithM_ a -> b -> m c
    f = \v a
    as v b
    bs -> (a -> b -> m c) -> Bundle v a -> Bundle v b -> m ()
    forall (m :: * -> *) a b c (v :: * -> *).
    Monad m =>
    (a -> b -> m c) -> Bundle v a -> Bundle v b -> m ()
    Bundle.zipWithM_ a -> b -> m c
    f (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as) (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs)

    -- | /O(min(m,n))/ Zip the two vectors with a monadic action that also takes
    -- the element index and ignore the results.
    izipWithM_ :: (Monad m, Vector v a, Vector v b)
              => (Int -> a -> b -> m c) -> v a -> v b -> m ()
    {-# INLINE izipWithM_ #-}
    izipWithM_ :: forall (m :: * -> *) (v :: * -> *) a b c.
    (Monad m, Vector v a, Vector v b) =>
    (Int -> a -> b -> m c) -> v a -> v b -> m ()
    izipWithM_ Int -> a -> b -> m c
    m v a
    as v b
    bs = ((Int, a) -> b -> m c) -> Bundle v (Int, a) -> Bundle v b -> m ()
    forall (m :: * -> *) a b c (v :: * -> *).
    Monad m =>
    (a -> b -> m c) -> Bundle v a -> Bundle v b -> m ()
    Bundle.zipWithM_ ((Int -> a -> b -> m c) -> (Int, a) -> b -> m c
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b -> m c
    m)
                          (Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    as))
                          (Bundle v b -> m ()) -> Bundle v b -> m ()
    forall a b. (a -> b) -> a -> b
    $ v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    bs

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

    -- | /O(min(m,n))/ Unzip a vector of pairs.
    unzip :: (Vector v a, Vector v b, Vector v (a,b)) => v (a, b) -> (v a, v b)
    {-# INLINE unzip #-}
    unzip :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b, Vector v (a, b)) =>
    v (a, b) -> (v a, v b)
    unzip v (a, b)
    xs = (((a, b) -> a) -> v (a, b) -> v a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (a, b) -> a
    forall a b. (a, b) -> a
    fst v (a, b)
    xs, ((a, b) -> b) -> v (a, b) -> v b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (a, b) -> b
    forall a b. (a, b) -> b
    snd v (a, b)
    xs)

    unzip3 :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c))
           => v (a, b, c) -> (v a, v b, v c)
    {-# INLINE unzip3 #-}
    unzip3 :: 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)
    unzip3 v (a, b, c)
    xs = (((a, b, c) -> a) -> v (a, b, c) -> v a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    a, b
    _, c
    _) -> a
    a) v (a, b, c)
    xs,
                 ((a, b, c) -> b) -> v (a, b, c) -> v b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    _, b
    b, c
    _) -> b
    b) v (a, b, c)
    xs,
                 ((a, b, c) -> c) -> v (a, b, c) -> v c
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    _, b
    _, c
    c) -> c
    c) v (a, b, c)
    xs)

    unzip4 :: (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)
    {-# INLINE unzip4 #-}
    unzip4 :: 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)
    unzip4 v (a, b, c, d)
    xs = (((a, b, c, d) -> a) -> v (a, b, c, d) -> v a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    a, b
    _, c
    _, d
    _) -> a
    a) v (a, b, c, d)
    xs,
                 ((a, b, c, d) -> b) -> v (a, b, c, d) -> v b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    _, b
    b, c
    _, d
    _) -> b
    b) v (a, b, c, d)
    xs,
                 ((a, b, c, d) -> c) -> v (a, b, c, d) -> v c
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    _, b
    _, c
    c, d
    _) -> c
    c) v (a, b, c, d)
    xs,
                 ((a, b, c, d) -> d) -> v (a, b, c, d) -> v d
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    _, b
    _, c
    _, d
    d) -> d
    d) v (a, b, c, d)
    xs)

    unzip5 :: (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)
    {-# INLINE unzip5 #-}
    unzip5 :: 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)
    unzip5 v (a, b, c, d, e)
    xs = (((a, b, c, d, e) -> a) -> v (a, b, c, d, e) -> v a
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    a, b
    _, c
    _, d
    _, e
    _) -> a
    a) v (a, b, c, d, e)
    xs,
                 ((a, b, c, d, e) -> b) -> v (a, b, c, d, e) -> v b
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    _, b
    b, c
    _, d
    _, e
    _) -> b
    b) v (a, b, c, d, e)
    xs,
                 ((a, b, c, d, e) -> c) -> v (a, b, c, d, e) -> v c
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    _, b
    _, c
    c, d
    _, e
    _) -> c
    c) v (a, b, c, d, e)
    xs,
                 ((a, b, c, d, e) -> d) -> v (a, b, c, d, e) -> v d
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    _, b
    _, c
    _, d
    d, e
    _) -> d
    d) v (a, b, c, d, e)
    xs,
                 ((a, b, c, d, e) -> e) -> v (a, b, c, d, e) -> v e
    forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b) -> v a -> v b
    map (\(a
    _, b
    _, c
    _, d
    _, e
    e) -> e
    e) v (a, b, c, d, e)
    xs)

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

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

    -- | /O(n)/ Drop all elements that do not satisfy the predicate.
    filter :: Vector v a => (a -> Bool) -> v a -> v a
    {-# INLINE filter #-}
    filter :: forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> v a
    filter a -> Bool
    f = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
    -> (Size -> Size) -> Bundle v a -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> Bool) -> Stream m a -> Stream m a
    forall (m :: * -> *) a.
    Monad m =>
    (a -> Bool) -> Stream m a -> Stream m a
    S.filter a -> Bool
    f) Size -> Size
    toMax (Bundle v a -> Bundle v a)
    -> (v a -> Bundle v a) -> v a -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Drop all elements that do not satisfy the predicate which is applied to
    -- the values and their indices.
    ifilter :: Vector v a => (Int -> a -> Bool) -> v a -> v a
    {-# INLINE ifilter #-}
    ifilter :: forall (v :: * -> *) a.
    Vector v a =>
    (Int -> a -> Bool) -> v a -> v a
    ifilter Int -> a -> Bool
    f = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
              (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
    -> (Size -> Size) -> Bundle v a -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace (((Int, a) -> a) -> Stream m (Int, a) -> Stream m a
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b) -> Stream m a -> Stream m b
    S.map (Int, a) -> a
    forall a b. (a, b) -> b
    snd (Stream m (Int, a) -> Stream m a)
    -> (Stream m a -> Stream m (Int, a)) -> Stream m a -> Stream m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((Int, a) -> Bool) -> Stream m (Int, a) -> Stream m (Int, a)
    forall (m :: * -> *) a.
    Monad m =>
    (a -> Bool) -> Stream m a -> Stream m a
    S.filter ((Int -> a -> Bool) -> (Int, a) -> Bool
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> Bool
    f) (Stream m (Int, a) -> Stream m (Int, a))
    -> (Stream m a -> Stream m (Int, a))
    -> Stream m a
    -> Stream m (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Stream m a -> Stream m (Int, a)
    forall (m :: * -> *) a. Monad m => Stream m a -> Stream m (Int, a)
    S.indexed) Size -> Size
    toMax
              (Bundle v a -> Bundle v a)
    -> (v a -> Bundle v a) -> v a -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Drop repeated adjacent elements. The first element in each group is returned.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector.Strict 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']
    uniq :: (Vector v a, Eq a) => v a -> v a
    {-# INLINE uniq #-}
    uniq :: forall (v :: * -> *) a. (Vector v a, Eq a) => v a -> v a
    uniq = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
    -> (Size -> Size) -> Bundle v a -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace Stream m a -> Stream m a
    forall a (m :: * -> *). (Eq a, Monad m) => Stream m a -> Stream m a
    forall (m :: * -> *). Monad m => Stream m a -> Stream m a
    S.uniq Size -> Size
    toMax (Bundle v a -> Bundle v a)
    -> (v a -> Bundle v a) -> v a -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Map the values and collect the 'Just' results.
    mapMaybe :: (Vector v a, Vector v b) => (a -> Maybe b) -> v a -> v b
    {-# INLINE mapMaybe #-}
    mapMaybe :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> Maybe b) -> v a -> v b
    mapMaybe a -> Maybe b
    f = Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> Maybe b) -> Stream m a -> Stream m b
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> Maybe b) -> Stream m a -> Stream m b
    S.mapMaybe a -> Maybe b
    f) Size -> Size
    toMax (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Map the indices/values and collect the 'Just' results.
    imapMaybe :: (Vector v a, Vector v b) => (Int -> a -> Maybe b) -> v a -> v b
    {-# INLINE imapMaybe #-}
    imapMaybe :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> Maybe b) -> v a -> v b
    imapMaybe Int -> a -> Maybe b
    f = Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
              (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace (((Int, a) -> Maybe b) -> Stream m (Int, a) -> Stream m b
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> Maybe b) -> Stream m a -> Stream m b
    S.mapMaybe ((Int -> a -> Maybe b) -> (Int, a) -> Maybe b
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> Maybe b
    f) (Stream m (Int, a) -> Stream m b)
    -> (Stream m a -> Stream m (Int, a)) -> Stream m a -> Stream m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Stream m a -> Stream m (Int, a)
    forall (m :: * -> *) a. Monad m => Stream m a -> Stream m (Int, a)
    S.indexed) Size -> Size
    toMax
              (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Drop all elements that do not satisfy the monadic predicate.
    filterM :: (Monad m, Vector v a) => (a -> m Bool) -> v a -> m (v a)
    {-# INLINE filterM #-}
    filterM :: forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    (a -> m Bool) -> v a -> m (v a)
    filterM a -> m Bool
    f = MBundle m v a -> m (v a)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (MBundle m v a -> m (v a))
    -> (v a -> MBundle m v a) -> v a -> m (v a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> m Bool) -> Bundle v a -> MBundle m v a
    forall (m :: * -> *) a (v :: * -> *).
    Monad m =>
    (a -> m Bool) -> Bundle v a -> Bundle m v a
    Bundle.filterM a -> m Bool
    f (Bundle v a -> MBundle m v a)
    -> (v a -> Bundle v a) -> v a -> MBundle m v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

    -- | /O(n)/ Apply the monadic function to each element of the vector and its index.
    -- Discard elements returning 'Nothing'.
    --
    -- @since 0.12.2.0
    imapMaybeM :: (Monad m, Vector v a, Vector v b)
          => (Int -> a -> m (Maybe b)) -> v a -> m (v b)
    {-# INLINE imapMaybeM #-}
    imapMaybeM :: forall (m :: * -> *) (v :: * -> *) a b.
    (Monad m, Vector v a, Vector v b) =>
    (Int -> a -> m (Maybe b)) -> v a -> m (v b)
    imapMaybeM Int -> a -> m (Maybe b)
    f = MBundle m v b -> m (v b)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM (MBundle m v b -> m (v b))
    -> (v a -> MBundle m v b) -> v a -> m (v b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((Int, a) -> m (Maybe b)) -> Bundle v (Int, a) -> MBundle m v b
    forall (m :: * -> *) a b (v :: * -> *).
    Monad m =>
    (a -> m (Maybe b)) -> Bundle v a -> Bundle m v b
    Bundle.mapMaybeM (\(Int
    i, a
    a) -> Int -> a -> m (Maybe b)
    f Int
    i a
    a) (Bundle v (Int, a) -> MBundle m v b)
    -> (v a -> Bundle v (Int, a)) -> v a -> MBundle m v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v a -> Bundle v (Int, a))
    -> (v a -> Bundle v a) -> v a -> Bundle v (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /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.
    takeWhile :: Vector v a => (a -> Bool) -> v a -> v a
    {-# INLINE takeWhile #-}
    takeWhile :: forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> v a
    takeWhile a -> Bool
    f = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Bool) -> Bundle v a -> Bundle v a
    forall a (v :: * -> *). (a -> Bool) -> Bundle v a -> Bundle v a
    Bundle.takeWhile a -> Bool
    f (Bundle v a -> Bundle v a)
    -> (v a -> Bundle v a) -> v a -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Drop the longest prefix of elements that satisfy the predicate
    -- without copying.
    dropWhile :: Vector v a => (a -> Bool) -> v a -> v a
    {-# INLINE_FUSED dropWhile #-}
    -- In the case that the argument is an actual vector,
    -- this is a faster solution than stream fusion.
    dropWhile :: forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> v a
    dropWhile a -> Bool
    f v a
    xs = case (a -> Bool) -> v a -> Maybe Int
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> Maybe Int
    findIndex (Bool -> Bool
    not (Bool -> Bool) -> (a -> Bool) -> a -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Bool
    f) v a
    xs of
                       Just Int
    i  -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
    unsafeDrop Int
    i v a
    xs
                       Maybe Int
    Nothing -> v a
    forall (v :: * -> *) a. Vector v a => v a
    empty

    -- If we have optimization turned on
    -- and the argument to 'dropWhile' comes from a stream,
    -- we never allocate the argument vector, and
    -- whenever possible, we avoid creating the resulting vector actually in heap.
    --
    -- Also note that @'new' . 'New.unstream'@
    -- is the definition (to be @INLINE@d) of 'unstream'.
    {-# RULES
    "dropWhile/unstream [Vector]" forall f p.
      dropWhile f (new (New.unstream p)) = new (New.unstream (Bundle.dropWhile f p))
      #-}

    -- 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'.
    partition :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
    {-# INLINE partition #-}
    partition :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    partition a -> Bool
    f = (a -> Bool) -> Bundle v a -> (v a, v a)
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    (a -> Bool) -> Bundle u a -> (v a, v a)
    partition_stream a -> Bool
    f (Bundle v a -> (v a, v a))
    -> (v a -> Bundle v a) -> v a -> (v a, v a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- FIXME: Make this inplace-fusible (look at how stable_partition is
    -- implemented in C++)

    partition_stream :: Vector v a => (a -> Bool) -> Bundle u a -> (v a, v a)
    {-# INLINE_FUSED partition_stream #-}
    partition_stream :: forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    (a -> Bool) -> Bundle u a -> (v a, v a)
    partition_stream a -> Bool
    f Bundle u a
    s = Bundle u a
    s Bundle u a -> (v a, v a) -> (v a, v a)
    forall a b. a -> b -> b
    `seq` (forall s. ST s (v a, v a)) -> (v a, v a)
    forall a. (forall s. ST s a) -> a
    runST (
      do
        (mv1,mv2) <- (a -> Bool)
    -> Bundle u a
    -> ST
         s (Mutable v (PrimState (ST s)) a, Mutable v (PrimState (ST s)) a)
    forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *).
    (PrimMonad m, MVector v a) =>
    (a -> Bool)
    -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a)
    M.partitionBundle a -> Bool
    f Bundle u a
    s
        v1 <- unsafeFreeze mv1
        v2 <- unsafeFreeze mv2
        return (v1,v2))

    -- | /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.12.1.0
    partitionWith :: (Vector v a, Vector v b, Vector v c) => (a -> Either b c) -> v a -> (v b, v c)
    {-# INLINE partitionWith #-}
    partitionWith :: forall (v :: * -> *) a b c.
    (Vector v a, Vector v b, Vector v c) =>
    (a -> Either b c) -> v a -> (v b, v c)
    partitionWith a -> Either b c
    f = (a -> Either b c) -> Bundle v a -> (v b, v c)
    forall (v :: * -> *) a b c (u :: * -> *).
    (Vector v a, Vector v b, Vector v c) =>
    (a -> Either b c) -> Bundle u a -> (v b, v c)
    partition_with_stream a -> Either b c
    f (Bundle v a -> (v b, v c))
    -> (v a -> Bundle v a) -> v a -> (v b, v c)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    partition_with_stream :: (Vector v a, Vector v b, Vector v c) => (a -> Either b c) -> Bundle u a -> (v b, v c)
    {-# INLINE_FUSED partition_with_stream #-}
    partition_with_stream :: forall (v :: * -> *) a b c (u :: * -> *).
    (Vector v a, Vector v b, Vector v c) =>
    (a -> Either b c) -> Bundle u a -> (v b, v c)
    partition_with_stream a -> Either b c
    f Bundle u a
    s = Bundle u a
    s Bundle u a -> (v b, v c) -> (v b, v c)
    forall a b. a -> b -> b
    `seq` (forall s. ST s (v b, v c)) -> (v b, v c)
    forall a. (forall s. ST s a) -> a
    runST (
      do
        (mv1,mv2) <- (a -> Either b c)
    -> Bundle u a
    -> ST
         s (Mutable v (PrimState (ST s)) b, Mutable v (PrimState (ST s)) c)
    forall (m :: * -> *) (v :: * -> * -> *) a b c (u :: * -> *).
    (PrimMonad m, MVector v a, MVector v b, MVector v c) =>
    (a -> Either b c)
    -> Bundle u a -> m (v (PrimState m) b, v (PrimState m) c)
    M.partitionWithBundle a -> Either b c
    f Bundle u a
    s
        v1 <- unsafeFreeze mv1
        v2 <- unsafeFreeze mv2
        return (v1,v2))

    -- | /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'.
    unstablePartition :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
    {-# INLINE unstablePartition #-}
    unstablePartition :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    unstablePartition a -> Bool
    f = (a -> Bool) -> Bundle v a -> (v a, v a)
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    (a -> Bool) -> Bundle u a -> (v a, v a)
    unstablePartition_stream a -> Bool
    f (Bundle v a -> (v a, v a))
    -> (v a -> Bundle v a) -> v a -> (v a, v a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    unstablePartition_stream
      :: Vector v a => (a -> Bool) -> Bundle u a -> (v a, v a)
    {-# INLINE_FUSED unstablePartition_stream #-}
    unstablePartition_stream :: forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    (a -> Bool) -> Bundle u a -> (v a, v a)
    unstablePartition_stream a -> Bool
    f Bundle u a
    s = Bundle u a
    s Bundle u a -> (v a, v a) -> (v a, v a)
    forall a b. a -> b -> b
    `seq` (forall s. ST s (v a, v a)) -> (v a, v a)
    forall a. (forall s. ST s a) -> a
    runST (
      do
        (mv1,mv2) <- (a -> Bool)
    -> Bundle u a
    -> ST
         s (Mutable v (PrimState (ST s)) a, Mutable v (PrimState (ST s)) a)
    forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *).
    (PrimMonad m, MVector v a) =>
    (a -> Bool)
    -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a)
    M.unstablePartitionBundle a -> Bool
    f Bundle u a
    s
        v1 <- unsafeFreeze mv1
        v2 <- unsafeFreeze mv2
        return (v1,v2))

    unstablePartition_new :: Vector v a => (a -> Bool) -> New v a -> (v a, v a)
    {-# INLINE_FUSED unstablePartition_new #-}
    unstablePartition_new :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> New v a -> (v a, v a)
    unstablePartition_new a -> Bool
    f (New.New forall s. ST s (Mutable v s a)
    p) = (forall s. ST s (v a, v a)) -> (v a, v a)
    forall a. (forall s. ST s a) -> a
    runST (
      do
        mv <- ST s (Mutable v s a)
    forall s. ST s (Mutable v s a)
    p
        i <- M.unstablePartition f mv
        v <- unsafeFreeze mv
        return (unsafeTake i v, unsafeDrop i v))

    {-# RULES

    "unstablePartition" forall f p.
      unstablePartition_stream f (stream (new p))
        = unstablePartition_new f p   #-}

    -- FIXME: make span and break fusible

    -- | /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.Strict as V
    -- >>> V.span (<4) $ V.generate 10 id
    -- ([0,1,2,3],[4,5,6,7,8,9])
    span :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
    {-# INLINE span #-}
    span :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    span a -> Bool
    f = (a -> Bool) -> v a -> (v a, v a)
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    break (Bool -> Bool
    not (Bool -> Bool) -> (a -> Bool) -> a -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Bool
    f)

    -- | /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.Strict as V
    -- >>> V.break (>4) $ V.generate 10 id
    -- ([0,1,2,3,4],[5,6,7,8,9])
    break :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
    {-# INLINE break #-}
    break :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    break a -> Bool
    f v a
    xs = case (a -> Bool) -> v a -> Maybe Int
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> Maybe Int
    findIndex a -> Bool
    f v a
    xs of
                   Just Int
    i  -> (Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice Int
    0 Int
    i v a
    xs, Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice Int
    i (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    xs Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    i) v a
    xs)
                   Maybe Int
    Nothing -> (v a
    xs, v a
    forall (v :: * -> *) a. Vector v a => v a
    empty)

    -- | /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.Strict as V
    -- >>> V.spanR (>4) $ V.generate 10 id
    -- ([5,6,7,8,9],[0,1,2,3,4])
    spanR :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
    {-# INLINE spanR #-}
    spanR :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    spanR a -> Bool
    f = (a -> Bool) -> v a -> (v a, v a)
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    breakR (Bool -> Bool
    not (Bool -> Bool) -> (a -> Bool) -> a -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Bool
    f)

    -- | /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 NEXT_VERSION
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector.Strict as V
    -- >>> V.breakR (<5) $ V.generate 10 id
    -- ([5,6,7,8,9],[0,1,2,3,4])
    breakR :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
    {-# INLINE breakR #-}
    breakR :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> (v a, v a)
    breakR a -> Bool
    f v a
    xs = case (a -> Bool) -> v a -> Maybe Int
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> Maybe Int
    findIndexR a -> Bool
    f v a
    xs of
      Just Int
    i  -> ( Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice (Int
    iInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1) (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    xs Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1) v a
    xs
                 , Int -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
    unsafeSlice Int
    0     (Int
    iInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)               v a
    xs)
      Maybe Int
    Nothing -> (v a
    xs, v a
    forall (v :: * -> *) a. Vector v a => v a
    empty)

    -- | /O(n)/ Split a vector into a list of slices.
    --
    -- 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.
    --
    -- >>> import qualified Data.Vector.Strict 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'.
    --
    -- @since 0.13.0.1
    {-# INLINE groupBy #-}
    groupBy :: (Vector v a) => (a -> a -> Bool) -> v a -> [v a]
    groupBy :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Bool) -> v a -> [v a]
    groupBy a -> a -> Bool
    _ v a
    v | v a -> Bool
    forall (v :: * -> *) a. Vector v a => v a -> Bool
    null v a
    v = []
    groupBy a -> a -> Bool
    f v a
    v =
      let h :: a
    h = v a -> a
    forall (v :: * -> *) a. Vector v a => v a -> a
    unsafeHead v a
    v
          tl :: v a
    tl = v a -> v a
    forall (v :: * -> *) a. Vector v a => v a -> v a
    unsafeTail v a
    v
       in case (a -> Bool) -> v a -> Maybe Int
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> Maybe Int
    findIndex (Bool -> Bool
    not (Bool -> Bool) -> (a -> Bool) -> a -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> a -> Bool
    f a
    h) v a
    tl of
          Maybe Int
    Nothing -> [v a
    v]
          Just Int
    n -> Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
    unsafeTake (Int
    n Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) v a
    v v a -> [v a] -> [v a]
    forall a. a -> [a] -> [a]
    : (a -> a -> Bool) -> v a -> [v a]
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Bool) -> v a -> [v a]
    groupBy a -> a -> Bool
    f (Int -> v a -> v a
    forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
    unsafeDrop (Int
    n Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) v a
    v)

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

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

    infix 4 `elem`
    -- | /O(n)/ Check if the vector contains an element.
    elem :: (Vector v a, Eq a) => a -> v a -> Bool
    {-# INLINE elem #-}
    elem :: forall (v :: * -> *) a. (Vector v a, Eq a) => a -> v a -> Bool
    elem a
    x = a -> Bundle v a -> Bool
    forall a (v :: * -> *). Eq a => a -> Bundle v a -> Bool
    Bundle.elem a
    x (Bundle v a -> Bool) -> (v a -> Bundle v a) -> v a -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

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

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

    -- | /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.12.2.0
    findIndexR :: Vector v a => (a -> Bool) -> v a -> Maybe Int
    {-# INLINE findIndexR #-}
    findIndexR :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> Maybe Int
    findIndexR a -> Bool
    f v a
    v = (Int -> Int) -> Maybe Int -> Maybe Int
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    -) (Maybe Int -> Maybe Int)
    -> (Bundle (ZonkAny 10) a -> Maybe Int)
    -> Bundle (ZonkAny 10) a
    -> Maybe Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Bool) -> Bundle (ZonkAny 10) a -> Maybe Int
    forall a (v :: * -> *). (a -> Bool) -> Bundle v a -> Maybe Int
    Bundle.findIndex a -> Bool
    f (Bundle (ZonkAny 10) a -> Maybe Int)
    -> Bundle (ZonkAny 10) a -> Maybe Int
    forall a b. (a -> b) -> a -> b
    $ v a -> Bundle (ZonkAny 10) a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR v a
    v

    -- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending
    -- order.
    findIndices :: (Vector v a, Vector v Int) => (a -> Bool) -> v a -> v Int
    {-# INLINE findIndices #-}
    findIndices :: forall (v :: * -> *) a.
    (Vector v a, Vector v Int) =>
    (a -> Bool) -> v a -> v Int
    findIndices a -> Bool
    f = Bundle v Int -> v Int
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
                  (Bundle v Int -> v Int) -> (v a -> Bundle v Int) -> v a -> v Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m Int)
    -> (Size -> Size) -> Bundle v a -> Bundle v Int
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace (((Int, a) -> Int) -> Stream m (Int, a) -> Stream m Int
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b) -> Stream m a -> Stream m b
    S.map (Int, a) -> Int
    forall a b. (a, b) -> a
    fst (Stream m (Int, a) -> Stream m Int)
    -> (Stream m a -> Stream m (Int, a)) -> Stream m a -> Stream m Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((Int, a) -> Bool) -> Stream m (Int, a) -> Stream m (Int, a)
    forall (m :: * -> *) a.
    Monad m =>
    (a -> Bool) -> Stream m a -> Stream m a
    S.filter (a -> Bool
    f (a -> Bool) -> ((Int, a) -> a) -> (Int, a) -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Int, a) -> a
    forall a b. (a, b) -> b
    snd) (Stream m (Int, a) -> Stream m (Int, a))
    -> (Stream m a -> Stream m (Int, a))
    -> Stream m a
    -> Stream m (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Stream m a -> Stream m (Int, a)
    forall (m :: * -> *) a. Monad m => Stream m a -> Stream m (Int, a)
    S.indexed) Size -> Size
    toMax
                  (Bundle v a -> Bundle v Int)
    -> (v a -> Bundle v a) -> v a -> Bundle v Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /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'.
    elemIndex :: (Vector v a, Eq a) => a -> v a -> Maybe Int
    {-# INLINE elemIndex #-}
    elemIndex :: forall (v :: * -> *) a. (Vector v a, Eq a) => a -> v a -> Maybe Int
    elemIndex a
    x = (a -> Bool) -> v a -> Maybe Int
    forall (v :: * -> *) a.
    Vector v a =>
    (a -> Bool) -> v a -> Maybe Int
    findIndex (a
    x a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    ==)

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

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

    -- | /O(n)/ Left fold.
    foldl :: Vector v b => (a -> b -> a) -> a -> v b -> a
    {-# INLINE foldl #-}
    foldl :: forall (v :: * -> *) b a.
    Vector v b =>
    (a -> b -> a) -> a -> v b -> a
    foldl a -> b -> a
    f a
    z = (a -> b -> a) -> a -> Bundle v b -> a
    forall a b (v :: * -> *). (a -> b -> a) -> a -> Bundle v b -> a
    Bundle.foldl a -> b -> a
    f a
    z (Bundle v b -> a) -> (v b -> Bundle v b) -> v b -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Left fold on non-empty vectors.
    foldl1 :: Vector v a => (a -> a -> a) -> v a -> a
    {-# INLINE foldl1 #-}
    foldl1 :: forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
    foldl1 a -> a -> a
    f = (a -> a -> a) -> Bundle v a -> a
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldl1 a -> a -> a
    f (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Left fold with strict accumulator.
    foldl' :: Vector v b => (a -> b -> a) -> a -> v b -> a
    {-# INLINE foldl' #-}
    foldl' :: forall (v :: * -> *) b a.
    Vector v b =>
    (a -> b -> a) -> a -> v b -> a
    foldl' a -> b -> a
    f a
    z = (a -> b -> a) -> a -> Bundle v b -> a
    forall a b (v :: * -> *). (a -> b -> a) -> a -> Bundle v b -> a
    Bundle.foldl' a -> b -> a
    f a
    z (Bundle v b -> a) -> (v b -> Bundle v b) -> v b -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Left fold on non-empty vectors with strict accumulator.
    foldl1' :: Vector v a => (a -> a -> a) -> v a -> a
    {-# INLINE foldl1' #-}
    foldl1' :: forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
    foldl1' a -> a -> a
    f = (a -> a -> a) -> Bundle v a -> a
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldl1' a -> a -> a
    f (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Right fold.
    foldr :: Vector v a => (a -> b -> b) -> b -> v a -> b
    {-# INLINE foldr #-}
    foldr :: forall (v :: * -> *) a b.
    Vector v a =>
    (a -> b -> b) -> b -> v a -> b
    foldr a -> b -> b
    f b
    z = (a -> b -> b) -> b -> Bundle v a -> b
    forall a b (v :: * -> *). (a -> b -> b) -> b -> Bundle v a -> b
    Bundle.foldr a -> b -> b
    f b
    z (Bundle v a -> b) -> (v a -> Bundle v a) -> v a -> b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Right fold on non-empty vectors.
    foldr1 :: Vector v a => (a -> a -> a) -> v a -> a
    {-# INLINE foldr1 #-}
    foldr1 :: forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
    foldr1 a -> a -> a
    f = (a -> a -> a) -> Bundle v a -> a
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldr1 a -> a -> a
    f (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Right fold with a strict accumulator.
    foldr' :: Vector v a => (a -> b -> b) -> b -> v a -> b
    {-# INLINE foldr' #-}
    foldr' :: forall (v :: * -> *) a b.
    Vector v a =>
    (a -> b -> b) -> b -> v a -> b
    foldr' a -> b -> b
    f b
    z = (b -> a -> b) -> b -> Bundle (ZonkAny 11) a -> b
    forall a b (v :: * -> *). (a -> b -> a) -> a -> Bundle v b -> a
    Bundle.foldl' ((a -> b -> b) -> b -> a -> b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip a -> b -> b
    f) b
    z (Bundle (ZonkAny 11) a -> b)
    -> (v a -> Bundle (ZonkAny 11) a) -> v a -> b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle (ZonkAny 11) a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR

    -- | /O(n)/ Right fold on non-empty vectors with strict accumulator.
    foldr1' :: Vector v a => (a -> a -> a) -> v a -> a
    {-# INLINE foldr1' #-}
    foldr1' :: forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
    foldr1' a -> a -> a
    f = (a -> a -> a) -> Bundle (ZonkAny 12) a -> a
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldl1' ((a -> a -> a) -> a -> a -> a
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip a -> a -> a
    f) (Bundle (ZonkAny 12) a -> a)
    -> (v a -> Bundle (ZonkAny 12) a) -> v a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle (ZonkAny 12) a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR

    -- | /O(n)/ Left fold using a function applied to each element and its index.
    ifoldl :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
    {-# INLINE ifoldl #-}
    ifoldl :: forall (v :: * -> *) b a.
    Vector v b =>
    (a -> Int -> b -> a) -> a -> v b -> a
    ifoldl a -> Int -> b -> a
    f a
    z = (a -> (Int, b) -> a) -> a -> Bundle v (Int, b) -> a
    forall a b (v :: * -> *). (a -> b -> a) -> a -> Bundle v b -> a
    Bundle.foldl ((Int -> b -> a) -> (Int, b) -> a
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry ((Int -> b -> a) -> (Int, b) -> a)
    -> (a -> Int -> b -> a) -> a -> (Int, b) -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Int -> b -> a
    f) a
    z (Bundle v (Int, b) -> a) -> (v b -> Bundle v (Int, b)) -> v b -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v b -> Bundle v (Int, b)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v b -> Bundle v (Int, b))
    -> (v b -> Bundle v b) -> v b -> Bundle v (Int, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Left fold with strict accumulator using a function applied to each element
    -- and its index.
    ifoldl' :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a
    {-# INLINE ifoldl' #-}
    ifoldl' :: forall (v :: * -> *) b a.
    Vector v b =>
    (a -> Int -> b -> a) -> a -> v b -> a
    ifoldl' a -> Int -> b -> a
    f a
    z = (a -> (Int, b) -> a) -> a -> Bundle v (Int, b) -> a
    forall a b (v :: * -> *). (a -> b -> a) -> a -> Bundle v b -> a
    Bundle.foldl' ((Int -> b -> a) -> (Int, b) -> a
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry ((Int -> b -> a) -> (Int, b) -> a)
    -> (a -> Int -> b -> a) -> a -> (Int, b) -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Int -> b -> a
    f) a
    z (Bundle v (Int, b) -> a) -> (v b -> Bundle v (Int, b)) -> v b -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v b -> Bundle v (Int, b)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v b -> Bundle v (Int, b))
    -> (v b -> Bundle v b) -> v b -> Bundle v (Int, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Right fold using a function applied to each element and its index.
    ifoldr :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
    {-# INLINE ifoldr #-}
    ifoldr :: forall (v :: * -> *) a b.
    Vector v a =>
    (Int -> a -> b -> b) -> b -> v a -> b
    ifoldr Int -> a -> b -> b
    f b
    z = ((Int, a) -> b -> b) -> b -> Bundle v (Int, a) -> b
    forall a b (v :: * -> *). (a -> b -> b) -> b -> Bundle v a -> b
    Bundle.foldr ((Int -> a -> b -> b) -> (Int, a) -> b -> b
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b -> b
    f) b
    z (Bundle v (Int, a) -> b) -> (v a -> Bundle v (Int, a)) -> v a -> b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v a -> Bundle v (Int, a))
    -> (v a -> Bundle v a) -> v a -> Bundle v (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Right fold with strict accumulator using a function applied to each
    -- element and its index.
    ifoldr' :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b
    {-# INLINE ifoldr' #-}
    ifoldr' :: forall (v :: * -> *) a b.
    Vector v a =>
    (Int -> a -> b -> b) -> b -> v a -> b
    ifoldr' Int -> a -> b -> b
    f b
    z v a
    xs = (b -> (Int, a) -> b) -> b -> Bundle (ZonkAny 13) (Int, a) -> b
    forall a b (v :: * -> *). (a -> b -> a) -> a -> Bundle v b -> a
    Bundle.foldl' (((Int, a) -> b -> b) -> b -> (Int, a) -> b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ((Int -> a -> b -> b) -> (Int, a) -> b -> b
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b -> b
    f)) b
    z
                   (Bundle (ZonkAny 13) (Int, a) -> b)
    -> Bundle (ZonkAny 13) (Int, a) -> b
    forall a b. (a -> b) -> a -> b
    $ Int -> Bundle (ZonkAny 13) a -> Bundle (ZonkAny 13) (Int, a)
    forall (v :: * -> *) a. Int -> Bundle v a -> Bundle v (Int, a)
    Bundle.indexedR (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    xs) (Bundle (ZonkAny 13) a -> Bundle (ZonkAny 13) (Int, a))
    -> Bundle (ZonkAny 13) a -> Bundle (ZonkAny 13) (Int, a)
    forall a b. (a -> b) -> a -> b
    $ v a -> Bundle (ZonkAny 13) a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR v a
    xs

    -- | /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 cless. 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.12.2.0
    foldMap :: (Monoid m, Vector v a) => (a -> m) -> v a -> m
    {-# INLINE foldMap #-}
    foldMap :: forall m (v :: * -> *) a.
    (Monoid m, Vector v a) =>
    (a -> m) -> v a -> m
    foldMap a -> m
    f = (a -> m -> m) -> m -> v a -> m
    forall (v :: * -> *) a b.
    Vector v a =>
    (a -> b -> b) -> b -> v a -> b
    foldr (m -> m -> m
    forall a. Monoid a => a -> a -> a
    mappend (m -> m -> m) -> (a -> m) -> a -> m -> m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> m
    f) m
    forall a. Monoid a => a
    mempty

    -- | /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.12.2.0
    foldMap' :: (Monoid m, Vector v a) => (a -> m) -> v a -> m
    {-# INLINE foldMap' #-}
    foldMap' :: forall m (v :: * -> *) a.
    (Monoid m, Vector v a) =>
    (a -> m) -> v a -> m
    foldMap' a -> m
    f = (m -> a -> m) -> m -> v a -> m
    forall (v :: * -> *) b a.
    Vector v b =>
    (a -> b -> a) -> a -> v b -> a
    foldl' (\m
    acc a
    a -> m
    acc m -> m -> m
    forall a. Monoid a => a -> a -> a
    `mappend` a -> m
    f a
    a) m
    forall a. Monoid a => a
    mempty

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

    -- | /O(n)/ Check if all elements satisfy the predicate.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector.Strict 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
    all :: Vector v a => (a -> Bool) -> v a -> Bool
    {-# INLINE all #-}
    all :: forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> Bool
    all a -> Bool
    f = Bundle v Bool -> Bool
    forall (v :: * -> *). Bundle v Bool -> Bool
    Bundle.and (Bundle v Bool -> Bool) -> (v a -> Bundle v Bool) -> v a -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Bool) -> Bundle v a -> Bundle v Bool
    forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
    Bundle.map a -> Bool
    f (Bundle v a -> Bundle v Bool)
    -> (v a -> Bundle v a) -> v a -> Bundle v Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Check if any element satisfies the predicate.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector.Strict 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
    any :: Vector v a => (a -> Bool) -> v a -> Bool
    {-# INLINE any #-}
    any :: forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> Bool
    any a -> Bool
    f = Bundle v Bool -> Bool
    forall (v :: * -> *). Bundle v Bool -> Bool
    Bundle.or (Bundle v Bool -> Bool) -> (v a -> Bundle v Bool) -> v a -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Bool) -> Bundle v a -> Bundle v Bool
    forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
    Bundle.map a -> Bool
    f (Bundle v a -> Bundle v Bool)
    -> (v a -> Bundle v a) -> v a -> Bundle v Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

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

    -- | /O(n)/ Compute the sum of the elements.
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector.Strict as V
    -- >>> V.sum $ V.fromList [300,20,1]
    -- 321
    -- >>> V.sum (V.empty :: V.Vector Int)
    -- 0
    sum :: (Vector v a, Num a) => v a -> a
    {-# INLINE sum #-}
    sum :: forall (v :: * -> *) a. (Vector v a, Num a) => v a -> a
    sum = (a -> a -> a) -> a -> Bundle v a -> a
    forall a b (v :: * -> *). (a -> b -> a) -> a -> Bundle v b -> a
    Bundle.foldl' a -> a -> a
    forall a. Num a => a -> a -> a
    (+) a
    0 (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

    -- | /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.Strict 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'
    maximum :: (Vector v a, Ord a) => v a -> a
    {-# INLINE maximum #-}
    maximum :: forall (v :: * -> *) a. (Vector v a, Ord a) => v a -> a
    maximum = (a -> a -> a) -> Bundle v a -> a
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldl1' a -> a -> a
    forall a. Ord a => a -> a -> a
    max (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /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.Strict 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')
    maximumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
    {-# INLINE maximumBy #-}
    maximumBy :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Ordering) -> v a -> a
    maximumBy a -> a -> Ordering
    cmpr = (a -> a -> a) -> Bundle v a -> a
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldl1' a -> a -> a
    maxBy (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream
      where
        {-# INLINE maxBy #-}
        maxBy :: a -> a -> a
    maxBy a
    x a
    y = case a -> a -> Ordering
    cmpr a
    x a
    y of
                      Ordering
    LT -> a
    y
                      Ordering
    _  -> a
    x

    -- | /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.Strict 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.0.0
    maximumOn :: (Ord b, Vector v a) => (a -> b) -> v a -> a
    {-# INLINE maximumOn #-}
    maximumOn :: forall b (v :: * -> *) a.
    (Ord b, Vector v a) =>
    (a -> b) -> v a -> a
    maximumOn a -> b
    f = (a, b) -> a
    forall a b. (a, b) -> a
    fst ((a, b) -> a) -> (v a -> (a, b)) -> v a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((a, b) -> (a, b) -> (a, b)) -> Bundle v (a, b) -> (a, b)
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldl1' (a, b) -> (a, b) -> (a, b)
    forall {a} {a}. Ord a => (a, a) -> (a, a) -> (a, a)
    maxBy (Bundle v (a, b) -> (a, b))
    -> (v a -> Bundle v (a, b)) -> v a -> (a, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> (a, b)) -> Bundle v a -> Bundle v (a, b)
    forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
    Bundle.map (\a
    a -> (a
    a, a -> b
    f a
    a)) (Bundle v a -> Bundle v (a, b))
    -> (v a -> Bundle v a) -> v a -> Bundle v (a, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream
      where
        {-# INLINE maxBy #-}
        maxBy :: (a, a) -> (a, a) -> (a, a)
    maxBy (a, a)
    x (a, a)
    y = case a -> a -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare ((a, a) -> a
    forall a b. (a, b) -> b
    snd (a, a)
    x) ((a, a) -> a
    forall a b. (a, b) -> b
    snd (a, a)
    y) of
                      Ordering
    LT -> (a, a)
    y
                      Ordering
    _  -> (a, a)
    x

    -- | /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.Strict 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'
    minimum :: (Vector v a, Ord a) => v a -> a
    {-# INLINE minimum #-}
    minimum :: forall (v :: * -> *) a. (Vector v a, Ord a) => v a -> a
    minimum = (a -> a -> a) -> Bundle v a -> a
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldl1' a -> a -> a
    forall a. Ord a => a -> a -> a
    min (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /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.Strict 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')
    minimumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
    {-# INLINE minimumBy #-}
    minimumBy :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Ordering) -> v a -> a
    minimumBy a -> a -> Ordering
    cmpr = (a -> a -> a) -> Bundle v a -> a
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldl1' a -> a -> a
    minBy (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream
      where
        {-# INLINE minBy #-}
        minBy :: a -> a -> a
    minBy a
    x a
    y = case a -> a -> Ordering
    cmpr a
    x a
    y of
                      Ordering
    GT -> a
    y
                      Ordering
    _  -> a
    x

    -- | /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.Strict 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.0.0
    minimumOn :: (Ord b, Vector v a) => (a -> b) -> v a -> a
    {-# INLINE minimumOn #-}
    minimumOn :: forall b (v :: * -> *) a.
    (Ord b, Vector v a) =>
    (a -> b) -> v a -> a
    minimumOn a -> b
    f = (a, b) -> a
    forall a b. (a, b) -> a
    fst ((a, b) -> a) -> (v a -> (a, b)) -> v a -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((a, b) -> (a, b) -> (a, b)) -> Bundle v (a, b) -> (a, b)
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldl1' (a, b) -> (a, b) -> (a, b)
    forall {a} {a}. Ord a => (a, a) -> (a, a) -> (a, a)
    minBy (Bundle v (a, b) -> (a, b))
    -> (v a -> Bundle v (a, b)) -> v a -> (a, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> (a, b)) -> Bundle v a -> Bundle v (a, b)
    forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
    Bundle.map (\a
    a -> (a
    a, a -> b
    f a
    a)) (Bundle v a -> Bundle v (a, b))
    -> (v a -> Bundle v a) -> v a -> Bundle v (a, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream
      where
        {-# INLINE minBy #-}
        minBy :: (a, a) -> (a, a) -> (a, a)
    minBy (a, a)
    x (a, a)
    y = case a -> a -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare ((a, a) -> a
    forall a b. (a, b) -> b
    snd (a, a)
    x) ((a, a) -> a
    forall a b. (a, b) -> b
    snd (a, a)
    y) of
                      Ordering
    GT -> (a, a)
    y
                      Ordering
    _  -> (a, a)
    x

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

    -- | /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.Strict as V
    -- >>> V.maxIndexBy (comparing fst) $ V.fromList [(2,'a'), (1,'b')]
    -- 0
    -- >>> V.maxIndexBy (comparing fst) $ V.fromList [(1,'a'), (1,'b')]
    -- 0
    maxIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
    {-# INLINE maxIndexBy #-}
    maxIndexBy :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Ordering) -> v a -> Int
    maxIndexBy a -> a -> Ordering
    cmpr = (Int, a) -> Int
    forall a b. (a, b) -> a
    fst ((Int, a) -> Int) -> (v a -> (Int, a)) -> v a -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((Int, a) -> (Int, a) -> (Int, a)) -> Bundle v (Int, a) -> (Int, a)
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldl1' (Int, a) -> (Int, a) -> (Int, a)
    imax (Bundle v (Int, a) -> (Int, a))
    -> (v a -> Bundle v (Int, a)) -> v a -> (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v a -> Bundle v (Int, a))
    -> (v a -> Bundle v a) -> v a -> Bundle v (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream
      where
        imax :: (Int, a) -> (Int, a) -> (Int, a)
    imax (Int
    i,a
    x) (Int
    j,a
    y) = Int
    i Int -> (Int, a) -> (Int, a)
    forall a b. a -> b -> b
    `seq` Int
    j Int -> (Int, a) -> (Int, a)
    forall a b. a -> b -> b
    `seq`
                           case a -> a -> Ordering
    cmpr a
    x a
    y of
                             Ordering
    LT -> (Int
    j,a
    y)
                             Ordering
    _  -> (Int
    i,a
    x)

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

    -- | /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.Strict as V
    -- >>> V.minIndexBy (comparing fst) $ V.fromList [(2,'a'), (1,'b')]
    -- 1
    -- >>> V.minIndexBy (comparing fst) $ V.fromList [(1,'a'), (1,'b')]
    -- 0
    minIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
    {-# INLINE minIndexBy #-}
    minIndexBy :: forall (v :: * -> *) a.
    Vector v a =>
    (a -> a -> Ordering) -> v a -> Int
    minIndexBy a -> a -> Ordering
    cmpr = (Int, a) -> Int
    forall a b. (a, b) -> a
    fst ((Int, a) -> Int) -> (v a -> (Int, a)) -> v a -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((Int, a) -> (Int, a) -> (Int, a)) -> Bundle v (Int, a) -> (Int, a)
    forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
    Bundle.foldl1' (Int, a) -> (Int, a) -> (Int, a)
    imin (Bundle v (Int, a) -> (Int, a))
    -> (v a -> Bundle v (Int, a)) -> v a -> (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v a -> Bundle v (Int, a)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v a -> Bundle v (Int, a))
    -> (v a -> Bundle v a) -> v a -> Bundle v (Int, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream
      where
        imin :: (Int, a) -> (Int, a) -> (Int, a)
    imin (Int
    i,a
    x) (Int
    j,a
    y) = Int
    i Int -> (Int, a) -> (Int, a)
    forall a b. a -> b -> b
    `seq` Int
    j Int -> (Int, a) -> (Int, a)
    forall a b. a -> b -> b
    `seq`
                           case a -> a -> Ordering
    cmpr a
    x a
    y of
                             Ordering
    GT -> (Int
    j,a
    y)
                             Ordering
    _  -> (Int
    i,a
    x)

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

    -- | /O(n)/ Monadic fold.
    foldM :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a
    {-# INLINE foldM #-}
    foldM :: forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> b -> m a) -> a -> v b -> m a
    foldM a -> b -> m a
    m a
    z = (a -> b -> m a) -> a -> Bundle v b -> m a
    forall (m :: * -> *) a b (v :: * -> *).
    Monad m =>
    (a -> b -> m a) -> a -> Bundle v b -> m a
    Bundle.foldM a -> b -> m a
    m a
    z (Bundle v b -> m a) -> (v b -> Bundle v b) -> v b -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Monadic fold using a function applied to each element and its index.
    ifoldM :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> v b -> m a
    {-# INLINE ifoldM #-}
    ifoldM :: forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> Int -> b -> m a) -> a -> v b -> m a
    ifoldM a -> Int -> b -> m a
    m a
    z = (a -> (Int, b) -> m a) -> a -> Bundle v (Int, b) -> m a
    forall (m :: * -> *) a b (v :: * -> *).
    Monad m =>
    (a -> b -> m a) -> a -> Bundle v b -> m a
    Bundle.foldM ((Int -> b -> m a) -> (Int, b) -> m a
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry ((Int -> b -> m a) -> (Int, b) -> m a)
    -> (a -> Int -> b -> m a) -> a -> (Int, b) -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Int -> b -> m a
    m) a
    z (Bundle v (Int, b) -> m a)
    -> (v b -> Bundle v (Int, b)) -> v b -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v b -> Bundle v (Int, b)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v b -> Bundle v (Int, b))
    -> (v b -> Bundle v b) -> v b -> Bundle v (Int, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Monadic fold over non-empty vectors.
    fold1M :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m a
    {-# INLINE fold1M #-}
    fold1M :: forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    (a -> a -> m a) -> v a -> m a
    fold1M a -> a -> m a
    m = (a -> a -> m a) -> Bundle v a -> m a
    forall (m :: * -> *) a (v :: * -> *).
    Monad m =>
    (a -> a -> m a) -> Bundle v a -> m a
    Bundle.fold1M a -> a -> m a
    m (Bundle v a -> m a) -> (v a -> Bundle v a) -> v a -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Monadic fold with strict accumulator.
    foldM' :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a
    {-# INLINE foldM' #-}
    foldM' :: forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> b -> m a) -> a -> v b -> m a
    foldM' a -> b -> m a
    m a
    z = (a -> b -> m a) -> a -> Bundle v b -> m a
    forall (m :: * -> *) a b (v :: * -> *).
    Monad m =>
    (a -> b -> m a) -> a -> Bundle v b -> m a
    Bundle.foldM' a -> b -> m a
    m a
    z (Bundle v b -> m a) -> (v b -> Bundle v b) -> v b -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Monadic fold with strict accumulator using a function applied to each
    -- element and its index.
    ifoldM' :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> v b -> m a
    {-# INLINE ifoldM' #-}
    ifoldM' :: forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> Int -> b -> m a) -> a -> v b -> m a
    ifoldM' a -> Int -> b -> m a
    m a
    z = (a -> (Int, b) -> m a) -> a -> Bundle v (Int, b) -> m a
    forall (m :: * -> *) a b (v :: * -> *).
    Monad m =>
    (a -> b -> m a) -> a -> Bundle v b -> m a
    Bundle.foldM' ((Int -> b -> m a) -> (Int, b) -> m a
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry ((Int -> b -> m a) -> (Int, b) -> m a)
    -> (a -> Int -> b -> m a) -> a -> (Int, b) -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Int -> b -> m a
    m) a
    z (Bundle v (Int, b) -> m a)
    -> (v b -> Bundle v (Int, b)) -> v b -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v b -> Bundle v (Int, b)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v b -> Bundle v (Int, b))
    -> (v b -> Bundle v b) -> v b -> Bundle v (Int, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

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

    -- | /O(n)/ Monadic fold that discards the result.
    foldM_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m ()
    {-# INLINE foldM_ #-}
    foldM_ :: forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> b -> m a) -> a -> v b -> m ()
    foldM_ a -> b -> m a
    m a
    z = m a -> m ()
    forall (m :: * -> *) a. Monad m => m a -> m ()
    discard (m a -> m ()) -> (v b -> m a) -> v b -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> b -> m a) -> a -> Bundle v b -> m a
    forall (m :: * -> *) a b (v :: * -> *).
    Monad m =>
    (a -> b -> m a) -> a -> Bundle v b -> m a
    Bundle.foldM a -> b -> m a
    m a
    z (Bundle v b -> m a) -> (v b -> Bundle v b) -> v b -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Monadic fold that discards the result using a function applied to
    -- each element and its index.
    ifoldM_ :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> v b -> m ()
    {-# INLINE ifoldM_ #-}
    ifoldM_ :: forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> Int -> b -> m a) -> a -> v b -> m ()
    ifoldM_ a -> Int -> b -> m a
    m a
    z = m a -> m ()
    forall (m :: * -> *) a. Monad m => m a -> m ()
    discard (m a -> m ()) -> (v b -> m a) -> v b -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> (Int, b) -> m a) -> a -> Bundle v (Int, b) -> m a
    forall (m :: * -> *) a b (v :: * -> *).
    Monad m =>
    (a -> b -> m a) -> a -> Bundle v b -> m a
    Bundle.foldM ((Int -> b -> m a) -> (Int, b) -> m a
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry ((Int -> b -> m a) -> (Int, b) -> m a)
    -> (a -> Int -> b -> m a) -> a -> (Int, b) -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Int -> b -> m a
    m) a
    z (Bundle v (Int, b) -> m a)
    -> (v b -> Bundle v (Int, b)) -> v b -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v b -> Bundle v (Int, b)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v b -> Bundle v (Int, b))
    -> (v b -> Bundle v b) -> v b -> Bundle v (Int, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Monadic fold over non-empty vectors that discards the result.
    fold1M_ :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m ()
    {-# INLINE fold1M_ #-}
    fold1M_ :: forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    (a -> a -> m a) -> v a -> m ()
    fold1M_ a -> a -> m a
    m = m a -> m ()
    forall (m :: * -> *) a. Monad m => m a -> m ()
    discard (m a -> m ()) -> (v a -> m a) -> v a -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> a -> m a) -> Bundle v a -> m a
    forall (m :: * -> *) a (v :: * -> *).
    Monad m =>
    (a -> a -> m a) -> Bundle v a -> m a
    Bundle.fold1M a -> a -> m a
    m (Bundle v a -> m a) -> (v a -> Bundle v a) -> v a -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

    -- | /O(n)/ Monadic fold with strict accumulator that discards the result
    -- using a function applied to each element and its index.
    ifoldM'_ :: (Monad m, Vector v b) => (a -> Int -> b -> m a) -> a -> v b -> m ()
    {-# INLINE ifoldM'_ #-}
    ifoldM'_ :: forall (m :: * -> *) (v :: * -> *) b a.
    (Monad m, Vector v b) =>
    (a -> Int -> b -> m a) -> a -> v b -> m ()
    ifoldM'_ a -> Int -> b -> m a
    m a
    z = m a -> m ()
    forall (m :: * -> *) a. Monad m => m a -> m ()
    discard (m a -> m ()) -> (v b -> m a) -> v b -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> (Int, b) -> m a) -> a -> Bundle v (Int, b) -> m a
    forall (m :: * -> *) a b (v :: * -> *).
    Monad m =>
    (a -> b -> m a) -> a -> Bundle v b -> m a
    Bundle.foldM' ((Int -> b -> m a) -> (Int, b) -> m a
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry ((Int -> b -> m a) -> (Int, b) -> m a)
    -> (a -> Int -> b -> m a) -> a -> (Int, b) -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Int -> b -> m a
    m) a
    z (Bundle v (Int, b) -> m a)
    -> (v b -> Bundle v (Int, b)) -> v b -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v b -> Bundle v (Int, b)
    forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
    Bundle.indexed (Bundle v b -> Bundle v (Int, b))
    -> (v b -> Bundle v b) -> v b -> Bundle v (Int, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Monad fold over non-empty vectors with strict accumulator
    -- that discards the result.
    fold1M'_ :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m ()
    {-# INLINE fold1M'_ #-}
    fold1M'_ :: forall (m :: * -> *) (v :: * -> *) a.
    (Monad m, Vector v a) =>
    (a -> a -> m a) -> v a -> m ()
    fold1M'_ a -> a -> m a
    m = m a -> m ()
    forall (m :: * -> *) a. Monad m => m a -> m ()
    discard (m a -> m ()) -> (v a -> m a) -> v a -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> a -> m a) -> Bundle v a -> m a
    forall (m :: * -> *) a (v :: * -> *).
    Monad m =>
    (a -> a -> m a) -> Bundle v a -> m a
    Bundle.fold1M' a -> a -> m a
    m (Bundle v a -> m a) -> (v a -> Bundle v a) -> v a -> m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

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

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

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

    -- Scans
    -- -----

    -- | /O(n)/ Left-to-right prescan.
    --
    -- @
    -- prescanl f z = 'init' . 'scanl' f z
    -- @
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector.Strict as V
    -- >>> V.prescanl (+) 0 (V.fromList [1,2,3,4])
    -- [0,1,3,6]
    prescanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
    {-# INLINE prescanl #-}
    prescanl :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    prescanl a -> b -> a
    f a
    z = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v b -> Bundle v a) -> v b -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m b -> Stream m a)
    -> (Size -> Size) -> Bundle v b -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> b -> a) -> a -> Stream m b -> Stream m a
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.prescanl a -> b -> a
    f a
    z) Size -> Size
    forall a. a -> a
    id (Bundle v b -> Bundle v a)
    -> (v b -> Bundle v b) -> v b -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Left-to-right prescan with strict accumulator.
    prescanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
    {-# INLINE prescanl' #-}
    prescanl' :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    prescanl' a -> b -> a
    f a
    z = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v b -> Bundle v a) -> v b -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m b -> Stream m a)
    -> (Size -> Size) -> Bundle v b -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> b -> a) -> a -> Stream m b -> Stream m a
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.prescanl' a -> b -> a
    f a
    z) Size -> Size
    forall a. a -> a
    id (Bundle v b -> Bundle v a)
    -> (v b -> Bundle v b) -> v b -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Left-to-right postscan.
    --
    -- @
    -- postscanl f z = 'tail' . 'scanl' f z
    -- @
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector.Strict as V
    -- >>> V.postscanl (+) 0 (V.fromList [1,2,3,4])
    -- [1,3,6,10]
    postscanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
    {-# INLINE postscanl #-}
    postscanl :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    postscanl a -> b -> a
    f a
    z = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v b -> Bundle v a) -> v b -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m b -> Stream m a)
    -> (Size -> Size) -> Bundle v b -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> b -> a) -> a -> Stream m b -> Stream m a
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.postscanl a -> b -> a
    f a
    z) Size -> Size
    forall a. a -> a
    id (Bundle v b -> Bundle v a)
    -> (v b -> Bundle v b) -> v b -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Left-to-right postscan with strict accumulator.
    postscanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
    {-# INLINE postscanl' #-}
    postscanl' :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    postscanl' a -> b -> a
    f a
    z = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v b -> Bundle v a) -> v b -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m b -> Stream m a)
    -> (Size -> Size) -> Bundle v b -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> b -> a) -> a -> Stream m b -> Stream m a
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.postscanl' a -> b -> a
    f a
    z) Size -> Size
    forall a. a -> a
    id (Bundle v b -> Bundle v a)
    -> (v b -> Bundle v b) -> v b -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /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.Strict as V
    -- >>> V.scanl (+) 0 (V.fromList [1,2,3,4])
    -- [0,1,3,6,10]
    scanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
    {-# INLINE scanl #-}
    scanl :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    scanl a -> b -> a
    f a
    z = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v b -> Bundle v a) -> v b -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> b -> a) -> a -> Bundle v b -> Bundle v a
    forall a b (v :: * -> *).
    (a -> b -> a) -> a -> Bundle v b -> Bundle v a
    Bundle.scanl a -> b -> a
    f a
    z (Bundle v b -> Bundle v a)
    -> (v b -> Bundle v b) -> v b -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Left-to-right scan with strict accumulator.
    scanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
    {-# INLINE scanl' #-}
    scanl' :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> a) -> a -> v b -> v a
    scanl' a -> b -> a
    f a
    z = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v b -> Bundle v a) -> v b -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> b -> a) -> a -> Bundle v b -> Bundle v a
    forall a b (v :: * -> *).
    (a -> b -> a) -> a -> Bundle v b -> Bundle v a
    Bundle.scanl' a -> b -> a
    f a
    z (Bundle v b -> Bundle v a)
    -> (v b -> Bundle v b) -> v b -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Left-to-right scan over a vector with its index.
    iscanl :: (Vector v a, Vector v b) => (Int -> a -> b -> a) -> a -> v b -> v a
    {-# INLINE iscanl #-}
    iscanl :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> b -> a) -> a -> v b -> v a
    iscanl Int -> a -> b -> a
    f a
    z =
        Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
      (Bundle v a -> v a) -> (v b -> Bundle v a) -> v b -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m b -> Stream m a)
    -> (Size -> Size) -> Bundle v b -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> (Int, b) -> a) -> a -> Stream m (Int, b) -> Stream m a
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.scanl (\a
    a (Int
    i, b
    b) -> Int -> a -> b -> a
    f Int
    i a
    a b
    b) a
    z (Stream m (Int, b) -> Stream m a)
    -> (Stream m b -> Stream m (Int, b)) -> Stream m b -> Stream m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Stream m b -> Stream m (Int, b)
    forall (m :: * -> *) a. Monad m => Stream m a -> Stream m (Int, a)
    S.indexed) (Size -> Size -> Size
    forall a. Num a => a -> a -> a
    +Size
    1)
      (Bundle v b -> Bundle v a)
    -> (v b -> Bundle v b) -> v b -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Left-to-right scan over a vector (strictly) with its index.
    iscanl' :: (Vector v a, Vector v b) => (Int -> a -> b -> a) -> a -> v b -> v a
    {-# INLINE iscanl' #-}
    iscanl' :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> b -> a) -> a -> v b -> v a
    iscanl' Int -> a -> b -> a
    f a
    z =
        Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream
      (Bundle v a -> v a) -> (v b -> Bundle v a) -> v b -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m b -> Stream m a)
    -> (Size -> Size) -> Bundle v b -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> (Int, b) -> a) -> a -> Stream m (Int, b) -> Stream m a
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.scanl' (\a
    a (Int
    i, b
    b) -> Int -> a -> b -> a
    f Int
    i a
    a b
    b) a
    z (Stream m (Int, b) -> Stream m a)
    -> (Stream m b -> Stream m (Int, b)) -> Stream m b -> Stream m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Stream m b -> Stream m (Int, b)
    forall (m :: * -> *) a. Monad m => Stream m a -> Stream m (Int, a)
    S.indexed) (Size -> Size -> Size
    forall a. Num a => a -> a -> a
    +Size
    1)
      (Bundle v b -> Bundle v a)
    -> (v b -> Bundle v b) -> v b -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /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.Strict 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)
    -- []
    scanl1 :: Vector v a => (a -> a -> a) -> v a -> v a
    {-# INLINE scanl1 #-}
    scanl1 :: forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
    scanl1 a -> a -> a
    f = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
    -> (Size -> Size) -> Bundle v a -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> a -> a) -> Stream m a -> Stream m a
    forall (m :: * -> *) a.
    Monad m =>
    (a -> a -> a) -> Stream m a -> Stream m a
    S.scanl1 a -> a -> a
    f) Size -> Size
    forall a. a -> a
    id (Bundle v a -> Bundle v a)
    -> (v a -> Bundle v a) -> v a -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /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.Strict 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)
    -- []
    scanl1' :: Vector v a => (a -> a -> a) -> v a -> v a
    {-# INLINE scanl1' #-}
    scanl1' :: forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
    scanl1' a -> a -> a
    f = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
    -> (Size -> Size) -> Bundle v a -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> a -> a) -> Stream m a -> Stream m a
    forall (m :: * -> *) a.
    Monad m =>
    (a -> a -> a) -> Stream m a -> Stream m a
    S.scanl1' a -> a -> a
    f) Size -> Size
    forall a. a -> a
    id (Bundle v a -> Bundle v a)
    -> (v a -> Bundle v a) -> v a -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /O(n)/ Right-to-left prescan.
    --
    -- @
    -- prescanr f z = 'reverse' . 'prescanl' (flip f) z . 'reverse'
    -- @
    prescanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
    {-# INLINE prescanr #-}
    prescanr :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    prescanr a -> b -> b
    f b
    z = Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstreamR (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((b -> a -> b) -> b -> Stream m a -> Stream m b
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.prescanl ((a -> b -> b) -> b -> a -> b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip a -> b -> b
    f) b
    z) Size -> Size
    forall a. a -> a
    id (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR

    -- | /O(n)/ Right-to-left prescan with strict accumulator.
    prescanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
    {-# INLINE prescanr' #-}
    prescanr' :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    prescanr' a -> b -> b
    f b
    z = Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstreamR (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((b -> a -> b) -> b -> Stream m a -> Stream m b
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.prescanl' ((a -> b -> b) -> b -> a -> b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip a -> b -> b
    f) b
    z) Size -> Size
    forall a. a -> a
    id (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR

    -- | /O(n)/ Right-to-left postscan.
    postscanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
    {-# INLINE postscanr #-}
    postscanr :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    postscanr a -> b -> b
    f b
    z = Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstreamR (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((b -> a -> b) -> b -> Stream m a -> Stream m b
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.postscanl ((a -> b -> b) -> b -> a -> b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip a -> b -> b
    f) b
    z) Size -> Size
    forall a. a -> a
    id (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR

    -- | /O(n)/ Right-to-left postscan with strict accumulator.
    postscanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
    {-# INLINE postscanr' #-}
    postscanr' :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    postscanr' a -> b -> b
    f b
    z = Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstreamR (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((b -> a -> b) -> b -> Stream m a -> Stream m b
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.postscanl' ((a -> b -> b) -> b -> a -> b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip a -> b -> b
    f) b
    z) Size -> Size
    forall a. a -> a
    id (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR

    -- | /O(n)/ Right-to-left scan.
    scanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
    {-# INLINE scanr #-}
    scanr :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    scanr a -> b -> b
    f b
    z = Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstreamR (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (b -> a -> b) -> b -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (a -> b -> a) -> a -> Bundle v b -> Bundle v a
    Bundle.scanl ((a -> b -> b) -> b -> a -> b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip a -> b -> b
    f) b
    z (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR

    -- | /O(n)/ Right-to-left scan with strict accumulator.
    scanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
    {-# INLINE scanr' #-}
    scanr' :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> b) -> b -> v a -> v b
    scanr' a -> b -> b
    f b
    z = Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstreamR (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (b -> a -> b) -> b -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (a -> b -> a) -> a -> Bundle v b -> Bundle v a
    Bundle.scanl' ((a -> b -> b) -> b -> a -> b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip a -> b -> b
    f) b
    z (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR

    -- | /O(n)/ Right-to-left scan over a vector with its index.
    iscanr :: (Vector v a, Vector v b) => (Int -> a -> b -> b) -> b -> v a -> v b
    {-# INLINE iscanr #-}
    iscanr :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> b -> b) -> b -> v a -> v b
    iscanr Int -> a -> b -> b
    f b
    z v a
    v =
        Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstreamR
      (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((b -> (Int, a) -> b) -> b -> Stream m (Int, a) -> Stream m b
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.scanl (((Int, a) -> b -> b) -> b -> (Int, a) -> b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (((Int, a) -> b -> b) -> b -> (Int, a) -> b)
    -> ((Int, a) -> b -> b) -> b -> (Int, a) -> b
    forall a b. (a -> b) -> a -> b
    $ (Int -> a -> b -> b) -> (Int, a) -> b -> b
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b -> b
    f) b
    z (Stream m (Int, a) -> Stream m b)
    -> (Stream m a -> Stream m (Int, a)) -> Stream m a -> Stream m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Stream m a -> Stream m (Int, a)
    forall (m :: * -> *) a.
    Monad m =>
    Int -> Stream m a -> Stream m (Int, a)
    S.indexedR Int
    n) (Size -> Size -> Size
    forall a. Num a => a -> a -> a
    +Size
    1)
      (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR
      (v a -> v b) -> v a -> v b
    forall a b. (a -> b) -> a -> b
    $ v a
    v
     where n :: Int
    n = v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v

    -- | /O(n)/ Right-to-left scan over a vector (strictly) with its index.
    iscanr' :: (Vector v a, Vector v b) => (Int -> a -> b -> b) -> b -> v a -> v b
    {-# INLINE iscanr' #-}
    iscanr' :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (Int -> a -> b -> b) -> b -> v a -> v b
    iscanr' Int -> a -> b -> b
    f b
    z v a
    v =
        Bundle v b -> v b
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstreamR
      (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((b -> (Int, a) -> b) -> b -> Stream m (Int, a) -> Stream m b
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> b -> a) -> a -> Stream m b -> Stream m a
    S.scanl' (((Int, a) -> b -> b) -> b -> (Int, a) -> b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (((Int, a) -> b -> b) -> b -> (Int, a) -> b)
    -> ((Int, a) -> b -> b) -> b -> (Int, a) -> b
    forall a b. (a -> b) -> a -> b
    $ (Int -> a -> b -> b) -> (Int, a) -> b -> b
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Int -> a -> b -> b
    f) b
    z (Stream m (Int, a) -> Stream m b)
    -> (Stream m a -> Stream m (Int, a)) -> Stream m a -> Stream m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Stream m a -> Stream m (Int, a)
    forall (m :: * -> *) a.
    Monad m =>
    Int -> Stream m a -> Stream m (Int, a)
    S.indexedR Int
    n) (Size -> Size -> Size
    forall a. Num a => a -> a -> a
    +Size
    1)
      (Bundle v a -> Bundle v b)
    -> (v a -> Bundle v a) -> v a -> Bundle v b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR
      (v a -> v b) -> v a -> v b
    forall a b. (a -> b) -> a -> b
    $ v a
    v
     where n :: Int
    n = v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v

    -- | /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.Strict 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)
    -- []
    scanr1 :: Vector v a => (a -> a -> a) -> v a -> v a
    {-# INLINE scanr1 #-}
    scanr1 :: forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
    scanr1 a -> a -> a
    f = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstreamR (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
    -> (Size -> Size) -> Bundle v a -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> a -> a) -> Stream m a -> Stream m a
    forall (m :: * -> *) a.
    Monad m =>
    (a -> a -> a) -> Stream m a -> Stream m a
    S.scanl1 ((a -> a -> a) -> a -> a -> a
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip a -> a -> a
    f)) Size -> Size
    forall a. a -> a
    id (Bundle v a -> Bundle v a)
    -> (v a -> Bundle v a) -> v a -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR

    -- | /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.Strict 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)
    -- []
    scanr1' :: Vector v a => (a -> a -> a) -> v a -> v a
    {-# INLINE scanr1' #-}
    scanr1' :: forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
    scanr1' a -> a -> a
    f = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstreamR (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
    -> (Size -> Size) -> Bundle v a -> Bundle v a
    forall a b (v :: * -> *).
    (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
    -> (Size -> Size) -> Bundle v a -> Bundle v b
    inplace ((a -> a -> a) -> Stream m a -> Stream m a
    forall (m :: * -> *) a.
    Monad m =>
    (a -> a -> a) -> Stream m a -> Stream m a
    S.scanl1' ((a -> a -> a) -> a -> a -> a
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip a -> a -> a
    f)) Size -> Size
    forall a. a -> a
    id (Bundle v a -> Bundle v a)
    -> (v a -> Bundle v a) -> v a -> Bundle v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR

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

    -- | /O(n)/ Convert a vector to a list.
    toList :: Vector v a => v a -> [a]
    {-# INLINE toList #-}
    toList :: forall (v :: * -> *) a. Vector v a => v a -> [a]
    toList = Bundle v a -> [a]
    forall (v :: * -> *) a. Bundle v a -> [a]
    Bundle.toList (Bundle v a -> [a]) -> (v a -> Bundle v a) -> v a -> [a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- | /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.4
    fromList :: Vector v a => [a] -> v a
    {-# INLINE fromList #-}
    fromList :: forall (v :: * -> *) a. Vector v a => [a] -> v a
    fromList = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> ([a] -> Bundle v a) -> [a] -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [a] -> Bundle v a
    forall a (v :: * -> *). [a] -> Bundle v a
    Bundle.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)
    -- @
    --
    -- ==== __Examples__
    --
    -- >>> import qualified Data.Vector.Strict as V
    -- >>> V.fromListN 3 [1,2,3,4,5]
    -- [1,2,3]
    -- >>> V.fromListN 3 [1]
    -- [1]
    fromListN :: Vector v a => Int -> [a] -> v a
    {-# INLINE fromListN #-}
    fromListN :: forall (v :: * -> *) a. Vector v a => Int -> [a] -> v a
    fromListN Int
    n = Bundle v a -> v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle v a -> v a) -> ([a] -> Bundle v a) -> [a] -> v a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> [a] -> Bundle v a
    forall a (v :: * -> *). Int -> [a] -> Bundle v a
    Bundle.fromListN Int
    n

    -- Conversions - Immutable vectors
    -- -------------------------------

    -- | /O(n)/ Convert between different vector types.
    convert :: (Vector v a, Vector w a) => v a -> w a
    {-# INLINE convert #-}
    convert :: forall (v :: * -> *) a (w :: * -> *).
    (Vector v a, Vector w a) =>
    v a -> w a
    convert = Bundle w a -> w a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream (Bundle w a -> w a) -> (v a -> Bundle w a) -> v a -> w a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bundle v a -> Bundle w a
    forall (u :: * -> *) a (v :: * -> *). Bundle u a -> Bundle v a
    Bundle.reVector (Bundle v a -> Bundle w a)
    -> (v a -> Bundle v a) -> v a -> Bundle w a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream

    -- 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.
    unsafeFreeze
      :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m (v a)
    {-# INLINE unsafeFreeze #-}
    unsafeFreeze :: forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m (v a)
    unsafeFreeze = ST (PrimState m) (v a) -> m (v a)
    forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a
    stToPrim (ST (PrimState m) (v a) -> m (v a))
    -> (Mutable v (PrimState m) a -> ST (PrimState m) (v a))
    -> Mutable v (PrimState m) a
    -> m (v a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Mutable v (PrimState m) a -> ST (PrimState m) (v a)
    forall s. Mutable v s a -> ST s (v a)
    forall (v :: * -> *) a s. Vector v a => Mutable v s a -> ST s (v a)
    basicUnsafeFreeze

    -- | /O(n)/ Yield an immutable copy of the mutable vector.
    freeze :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m (v a)
    {-# INLINE freeze #-}
    freeze :: forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m (v a)
    freeze Mutable v (PrimState m) a
    mv = Mutable v (PrimState m) a -> m (v a)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m (v a)
    unsafeFreeze (Mutable v (PrimState m) a -> m (v a))
    -> m (Mutable v (PrimState m) a) -> m (v a)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Mutable v (PrimState m) a -> m (Mutable v (PrimState m) a)
    forall (m :: * -> *) (v :: * -> * -> *) a.
    (PrimMonad m, MVector v a) =>
    v (PrimState m) a -> m (v (PrimState m) a)
    M.clone Mutable v (PrimState m) a
    mv

    -- | /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."
    unsafeThaw :: (PrimMonad m, Vector v a) => v a -> m (Mutable v (PrimState m) a)
    {-# INLINE_FUSED unsafeThaw #-}
    unsafeThaw :: forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    v a -> m (Mutable v (PrimState m) a)
    unsafeThaw = ST (PrimState m) (Mutable v (PrimState m) a)
    -> m (Mutable v (PrimState m) a)
    forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a
    stToPrim (ST (PrimState m) (Mutable v (PrimState m) a)
     -> m (Mutable v (PrimState m) a))
    -> (v a -> ST (PrimState m) (Mutable v (PrimState m) a))
    -> v a
    -> m (Mutable v (PrimState m) a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> ST (PrimState m) (Mutable v (PrimState m) a)
    forall s. v a -> ST s (Mutable v s a)
    forall (v :: * -> *) a s. Vector v a => v a -> ST s (Mutable v s a)
    basicUnsafeThaw

    -- | /O(n)/ Yield a mutable copy of an immutable vector.
    thaw :: (PrimMonad m, Vector v a) => v a -> m (Mutable v (PrimState m) a)
    {-# INLINE_FUSED thaw #-}
    thaw :: forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    v a -> m (Mutable v (PrimState m) a)
    thaw v a
    v = do
               mv <- Int -> m (Mutable v (PrimState m) a)
    forall (m :: * -> *) (v :: * -> * -> *) a.
    (PrimMonad m, MVector v a) =>
    Int -> m (v (PrimState m) a)
    M.unsafeNew (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v)
               unsafeCopy mv v
               return mv

    {-# RULES

    "unsafeThaw/new [Vector]" forall p.
      unsafeThaw (new p) = New.runPrim p

    "thaw/new [Vector]" forall p.
      thaw (new p) = New.runPrim p   #-}

    {-
    -- | /O(n)/ Yield a mutable vector containing copies of each vector in the
    -- list.
    thawMany :: (PrimMonad m, Vector v a) => [v a] -> m (Mutable v (PrimState m) a)
    {-# INLINE_FUSED thawMany #-}
    -- FIXME: add rule for (stream (new (New.create (thawMany vs))))
    -- NOTE: We don't try to consume the list lazily as this wouldn't significantly
    -- change the space requirements anyway.
    thawMany vs = do
                    mv <- M.new n
                    thaw_loop mv vs
                    return mv
      where
        n = List.foldl' (\k v -> k + length v) 0 vs

        thaw_loop mv [] = mv `seq` return ()
        thaw_loop mv (v:vs)
          = do
              let n = length v
              unsafeCopy (M.unsafeTake n mv) v
              thaw_loop (M.unsafeDrop n mv) vs
    -}

    -- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
    -- have the same length. This is not checked.
    unsafeCopy :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
    {-# INLINE unsafeCopy #-}
    unsafeCopy :: forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> v a -> m ()
    unsafeCopy Mutable v (PrimState m) a
    dst v a
    src = Checks -> String -> Bool -> m () -> m ()
    forall a. HasCallStack => Checks -> String -> Bool -> a -> a
    check Checks
    Unsafe String
    "length mismatch" (Mutable v (PrimState m) a -> Int
    forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
    M.length Mutable v (PrimState m) a
    dst Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    basicLength v a
    src)
                       (m () -> m ()) -> m () -> m ()
    forall a b. (a -> b) -> a -> b
    $ (Mutable v (PrimState m) a
    dst Mutable v (PrimState m) a -> m () -> m ()
    forall a b. a -> b -> b
    `seq` v a
    src v a -> m () -> m ()
    forall a b. a -> b -> b
    `seq` ST (PrimState m) () -> m ()
    forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a
    stToPrim (Mutable v (PrimState m) a -> v a -> ST (PrimState m) ()
    forall s. Mutable v s a -> v a -> ST s ()
    forall (v :: * -> *) a s.
    Vector v a =>
    Mutable v s a -> v a -> ST s ()
    basicUnsafeCopy Mutable v (PrimState m) a
    dst v a
    src))

    -- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
    -- have the same length.
    copy :: (HasCallStack, PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
    {-# INLINE copy #-}
    copy :: forall (m :: * -> *) (v :: * -> *) a.
    (HasCallStack, PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> v a -> m ()
    copy Mutable v (PrimState m) a
    dst v a
    src = Checks -> String -> Bool -> m () -> m ()
    forall a. HasCallStack => Checks -> String -> Bool -> a -> a
    check Checks
    Bounds String
    "length mismatch" (Mutable v (PrimState m) a -> Int
    forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
    M.length Mutable v (PrimState m) a
    dst Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    basicLength v a
    src)
                 (m () -> m ()) -> m () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Mutable v (PrimState m) a -> v a -> m ()
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> v a -> m ()
    unsafeCopy Mutable v (PrimState m) a
    dst v a
    src

    -- Conversions to/from Bundles
    -- ---------------------------

    -- | /O(1)/ Convert a vector to a 'Bundle'.
    stream :: Vector v a => v a -> Bundle v a
    {-# INLINE_FUSED stream #-}
    stream :: forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    v = v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    Bundle.fromVector v a
    v

    {-
    stream v = v `seq` n `seq` (Bundle.unfoldr get 0 `Bundle.sized` Exact n)
      where
        n = length v

        -- NOTE: the False case comes first in Core so making it the recursive one
        -- makes the code easier to read
        {-# INLINE get #-}
        get i | i >= n    = Nothing
              | otherwise = case basicUnsafeIndexM v i of Box x -> Just (x, i+1)
    -}

    -- | /O(n)/ Construct a vector from a 'Bundle'.
    unstream :: Vector v a => Bundle v a -> v a
    {-# INLINE unstream #-}
    unstream :: forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstream Bundle v a
    s = New v a -> v a
    forall (v :: * -> *) a. Vector v a => New v a -> v a
    new (Bundle v a -> New v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> New v a
    New.unstream Bundle v a
    s)

    {-# RULES

    "stream/unstream [Vector]" forall s.
      stream (new (New.unstream s)) = s

    "New.unstream/stream [Vector]" forall v.
      New.unstream (stream v) = clone v

    "clone/new [Vector]" forall p.
      clone (new p) = p

    "inplace [Vector]"
      forall (f :: forall m. Monad m => Stream m a -> Stream m a) g m.
      New.unstream (inplace f g (stream (new m))) = New.transform f g m

    "uninplace [Vector]"
      forall (f :: forall m. Monad m => Stream m a -> Stream m a) g m.
      stream (new (New.transform f g m)) = inplace f g (stream (new m))  #-}

    -- | /O(1)/ Convert a vector to a 'Bundle', proceeding from right to left.
    streamR :: Vector v a => v a -> Bundle u a
    {-# INLINE_FUSED streamR #-}
    streamR :: forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    v a -> Bundle u a
    streamR v a
    v = v a
    v v a -> Bundle u a -> Bundle u a
    forall a b. a -> b -> b
    `seq` Int
    n Int -> Bundle u a -> Bundle u a
    forall a b. a -> b -> b
    `seq` ((Int -> Maybe (a, Int)) -> Int -> Bundle u a
    forall s a (v :: * -> *). (s -> Maybe (a, s)) -> s -> Bundle v a
    Bundle.unfoldr Int -> Maybe (a, Int)
    get Int
    n Bundle u a -> Size -> Bundle u a
    forall (v :: * -> *) a. Bundle v a -> Size -> Bundle v a
    `Bundle.sized` Int -> Size
    Exact Int
    n)
      where
        n :: Int
    n = v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    length v a
    v

        {-# INLINE get #-}
        get :: Int -> Maybe (a, Int)
    get Int
    0 = Maybe (a, Int)
    forall a. Maybe a
    Nothing
        get Int
    i = let !i' :: Int
    i' = Int
    iInt -> Int -> Int
    forall a. Num a => a -> a -> a
    -Int
    1
                in
                case v a -> Int -> Box a
    forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
    basicUnsafeIndexM v a
    v Int
    i' of Box a
    x -> (a, Int) -> Maybe (a, Int)
    forall a. a -> Maybe a
    Just (a
    x, Int
    i')

    -- | /O(n)/ Construct a vector from a 'Bundle', proceeding from right to left.
    unstreamR :: Vector v a => Bundle v a -> v a
    {-# INLINE unstreamR #-}
    unstreamR :: forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
    unstreamR Bundle v a
    s = New v a -> v a
    forall (v :: * -> *) a. Vector v a => New v a -> v a
    new (Bundle v a -> New v a
    forall (v :: * -> *) a. Vector v a => Bundle v a -> New v a
    New.unstreamR Bundle v a
    s)

    {-# RULES

    "streamR/unstreamR [Vector]" forall s.
      streamR (new (New.unstreamR s)) = s

    "New.unstreamR/streamR/new [Vector]" forall p.
      New.unstreamR (streamR (new p)) = p

    "New.unstream/streamR/new [Vector]" forall p.
      New.unstream (streamR (new p)) = New.modify M.reverse p

    "New.unstreamR/stream/new [Vector]" forall p.
      New.unstreamR (stream (new p)) = New.modify M.reverse p

    "inplace right [Vector]"
      forall (f :: forall m. Monad m => Stream m a -> Stream m a) g m.
      New.unstreamR (inplace f g (streamR (new m))) = New.transformR f g m

    "uninplace right [Vector]"
      forall (f :: forall m. Monad m => Stream m a -> Stream m a) g m.
      streamR (new (New.transformR f g m)) = inplace f g (streamR (new m))  #-}

    -- | Load a monadic stream bundle into a newly allocated vector. This function goes through
    -- a list, so prefer using `unstream`, unless you need to be in a monad.
    --
    -- @since 0.12.2.0
    unstreamM :: (Monad m, Vector v a) => MBundle m u a -> m (v a)
    {-# INLINE_FUSED unstreamM #-}
    unstreamM :: forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (Monad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamM MBundle m u a
    s = do
                    xs <- MBundle m u a -> m [a]
    forall (m :: * -> *) (v :: * -> *) a.
    Monad m =>
    Bundle m v a -> m [a]
    MBundle.toList MBundle m u a
    s
                    return $ unstream $ Bundle.unsafeFromList (MBundle.size s) xs

    unstreamPrimM :: (PrimMonad m, Vector v a) => MBundle m u a -> m (v a)
    {-# INLINE_FUSED unstreamPrimM #-}
    unstreamPrimM :: forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (PrimMonad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamPrimM MBundle m u a
    s = MBundle m u a -> m (Mutable v (PrimState m) a)
    forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *).
    (PrimMonad m, MVector v a) =>
    MBundle m u a -> m (v (PrimState m) a)
    M.munstream MBundle m u a
    s m (Mutable v (PrimState m) a)
    -> (Mutable v (PrimState m) a -> m (v a)) -> m (v a)
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= Mutable v (PrimState m) a -> m (v a)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m (v a)
    unsafeFreeze

    -- FIXME: the next two functions are only necessary for the specialisations
    unstreamPrimM_IO :: Vector v a => MBundle IO u a -> IO (v a)
    {-# INLINE unstreamPrimM_IO #-}
    unstreamPrimM_IO :: forall (v :: * -> *) a (u :: * -> *).
    Vector v a =>
    MBundle IO u a -> IO (v a)
    unstreamPrimM_IO = MBundle IO u a -> IO (v a)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (PrimMonad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamPrimM

    unstreamPrimM_ST :: Vector v a => MBundle (ST s) u a -> ST s (v a)
    {-# INLINE unstreamPrimM_ST #-}
    unstreamPrimM_ST :: forall (v :: * -> *) a s (u :: * -> *).
    Vector v a =>
    MBundle (ST s) u a -> ST s (v a)
    unstreamPrimM_ST = MBundle (ST s) u a -> ST s (v a)
    forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
    (PrimMonad m, Vector v a) =>
    MBundle m u a -> m (v a)
    unstreamPrimM

    {-# RULES

    "unstreamM[IO]" unstreamM = unstreamPrimM_IO
    "unstreamM[ST]" unstreamM = unstreamPrimM_ST  #-}

    -- Recycling support
    -- -----------------

    -- | Construct a vector from a monadic initialiser.
    new :: Vector v a => New v a -> v a
    {-# INLINE_FUSED new #-}
    new :: forall (v :: * -> *) a. Vector v a => New v a -> v a
    new New v a
    m = New v a
    m New v a -> v a -> v a
    forall a b. a -> b -> b
    `seq` (forall s. ST s (v a)) -> v a
    forall a. (forall s. ST s a) -> a
    runST (Mutable v s a -> ST s (v a)
    Mutable v (PrimState (ST s)) a -> ST s (v a)
    forall (m :: * -> *) (v :: * -> *) a.
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m (v a)
    unsafeFreeze (Mutable v s a -> ST s (v a)) -> ST s (Mutable v s a) -> ST s (v a)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< New v a -> ST s (Mutable v s a)
    forall (v :: * -> *) a s. New v a -> ST s (Mutable v s a)
    New.run New v a
    m)

    -- | Convert a vector to an initialiser which, when run, produces a copy of
    -- the vector.
    clone :: Vector v a => v a -> New v a
    {-# INLINE_FUSED clone #-}
    clone :: forall (v :: * -> *) a. Vector v a => v a -> New v a
    clone v a
    v = v a
    v v a -> New v a -> New v a
    forall a b. a -> b -> b
    `seq` (forall s. ST s (Mutable v s a)) -> New v a
    forall (v :: * -> *) a. (forall s. ST s (Mutable v s a)) -> New v a
    New.create (
      do
        mv <- Int -> ST s (Mutable v (PrimState (ST s)) a)
    forall (m :: * -> *) (v :: * -> * -> *) a.
    (HasCallStack, PrimMonad m, MVector v a) =>
    Int -> m (v (PrimState m) a)
    M.new (v a -> Int
    forall (v :: * -> *) a. Vector v a => v a -> Int
    basicLength v a
    v)
        unsafeCopy mv v
        return mv)

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

    -- | /O(n)/ Check if two vectors are equal. All 'Vector' instances are also
    -- instances of 'Eq' and it is usually more appropriate to use those. This
    -- function is primarily intended for implementing 'Eq' instances for new
    -- vector types.
    eq :: (Vector v a, Eq a) => v a -> v a -> Bool
    {-# INLINE eq #-}
    v a
    xs eq :: forall (v :: * -> *) a. (Vector v a, Eq a) => v a -> v a -> Bool
    `eq` v a
    ys = v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    xs Bundle v a -> Bundle v a -> Bool
    forall a. Eq a => a -> a -> Bool
    == v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    ys

    -- | /O(n)/ Check if two vectors are equal using the supplied equality
    -- predicate.
    eqBy :: (Vector v a, Vector v b) => (a -> b -> Bool) -> v a -> v b -> Bool
    {-# INLINE eqBy #-}
    eqBy :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> Bool) -> v a -> v b -> Bool
    eqBy a -> b -> Bool
    e v a
    xs v b
    ys = (a -> b -> Bool) -> Bundle v a -> Bundle v b -> Bool
    forall a b (v :: * -> *).
    (a -> b -> Bool) -> Bundle v a -> Bundle v b -> Bool
    Bundle.eqBy a -> b -> Bool
    e (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    xs) (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    ys)

    -- | /O(n)/ Compare two vectors lexicographically. All 'Vector' instances are
    -- also instances of 'Ord' and it is usually more appropriate to use those. This
    -- function is primarily intended for implementing 'Ord' instances for new
    -- vector types.
    cmp :: (Vector v a, Ord a) => v a -> v a -> Ordering
    {-# INLINE cmp #-}
    cmp :: forall (v :: * -> *) a.
    (Vector v a, Ord a) =>
    v a -> v a -> Ordering
    cmp v a
    xs v a
    ys = Bundle v a -> Bundle v a -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    xs) (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    ys)

    -- | /O(n)/ Compare two vectors using the supplied comparison function for
    -- vector elements. Comparison works the same as for lists.
    --
    -- > cmpBy compare == cmp
    cmpBy :: (Vector v a, Vector v b) => (a -> b -> Ordering) -> v a -> v b -> Ordering
    cmpBy :: forall (v :: * -> *) a b.
    (Vector v a, Vector v b) =>
    (a -> b -> Ordering) -> v a -> v b -> Ordering
    cmpBy a -> b -> Ordering
    c v a
    xs v b
    ys = (a -> b -> Ordering) -> Bundle v a -> Bundle v b -> Ordering
    forall a b (v :: * -> *).
    (a -> b -> Ordering) -> Bundle v a -> Bundle v b -> Ordering
    Bundle.cmpBy a -> b -> Ordering
    c (v a -> Bundle v a
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v a
    xs) (v b -> Bundle v b
    forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
    stream v b
    ys)

    -- Show
    -- ----

    -- | Generic definition of 'Prelude.showsPrec'.
    showsPrec :: (Vector v a, Show a) => Int -> v a -> ShowS
    {-# INLINE showsPrec #-}
    showsPrec :: forall (v :: * -> *) a. (Vector v a, Show a) => Int -> v a -> ShowS
    showsPrec Int
    _ = [a] -> ShowS
    forall a. Show a => a -> ShowS
    shows ([a] -> ShowS) -> (v a -> [a]) -> v a -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> [a]
    forall (v :: * -> *) a. Vector v a => v a -> [a]
    toList

    liftShowsPrec :: (Vector v a) => (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> v a -> ShowS
    {-# INLINE liftShowsPrec #-}
    liftShowsPrec :: forall (v :: * -> *) a.
    Vector v a =>
    (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> v a -> ShowS
    liftShowsPrec Int -> a -> ShowS
    _ [a] -> ShowS
    s Int
    _ = [a] -> ShowS
    s ([a] -> ShowS) -> (v a -> [a]) -> v a -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . v a -> [a]
    forall (v :: * -> *) a. Vector v a => v a -> [a]
    toList

    -- | Generic definition of 'Text.Read.readPrec'.
    readPrec :: (Vector v a, Read a) => Read.ReadPrec (v a)
    {-# INLINE readPrec #-}
    readPrec :: forall (v :: * -> *) a. (Vector v a, Read a) => ReadPrec (v a)
    readPrec = do
      xs <- ReadPrec [a]
    forall a. Read a => ReadPrec a
    Read.readPrec
      return (fromList xs)

    -- | /Note:/ uses 'ReadS'.
    liftReadsPrec :: (Vector v a) => (Int -> Read.ReadS a) -> ReadS [a] -> Int -> Read.ReadS (v a)
    liftReadsPrec :: forall (v :: * -> *) a.
    Vector v a =>
    (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (v a)
    liftReadsPrec Int -> ReadS a
    _ ReadS [a]
    r Int
    _ String
    s = [ ([a] -> v a
    forall (v :: * -> *) a. Vector v a => [a] -> v a
    fromList [a]
    v, String
    s') | ([a]
    v, String
    s') <- ReadS [a]
    r String
    s ]

    -- Data and Typeable
    -- -----------------

    -- | Generic definion of 'Data.Data.gfoldl' that views a 'Vector' as a list.
    gfoldl :: (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)
    {-# INLINE gfoldl #-}
    gfoldl :: 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)
    gfoldl forall d b. Data d => c (d -> b) -> d -> c b
    f forall g. g -> c g
    z v a
    v = ([a] -> v a) -> c ([a] -> v a)
    forall g. g -> c g
    z [a] -> v a
    forall (v :: * -> *) a. Vector v a => [a] -> v a
    fromList c ([a] -> v a) -> [a] -> c (v a)
    forall d b. Data d => c (d -> b) -> d -> c b
    `f` v a -> [a]
    forall (v :: * -> *) a. Vector v a => v a -> [a]
    toList v a
    v

    mkVecConstr :: String -> Constr
    {-# INLINE mkVecConstr #-}
    mkVecConstr :: String -> Constr
    mkVecConstr String
    name = DataType -> String -> [String] -> Fixity -> Constr
    mkConstr (String -> DataType
    mkVecType String
    name) String
    "fromList" [] Fixity
    Prefix

    mkVecType :: String -> DataType
    {-# INLINE mkVecType #-}
    mkVecType :: String -> DataType
    mkVecType String
    name = String -> [Constr] -> DataType
    mkDataType String
    name [String -> Constr
    mkVecConstr String
    name]

    mkType :: String -> DataType
    {-# INLINE mkType #-}
    {-# DEPRECATED mkType "Use Data.Data.mkNoRepType" #-}
    mkType :: String -> DataType
    mkType = String -> DataType
    mkNoRepType

    gunfold :: (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)
    gunfold :: 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)
    gunfold forall b r. Data b => c (b -> r) -> c r
    k forall r. r -> c r
    z Constr
    c = case Constr -> Int
    constrIndex Constr
    c of
      Int
    1 -> c ([a] -> v a) -> c (v a)
    forall b r. Data b => c (b -> r) -> c r
    k (([a] -> v a) -> c ([a] -> v a)
    forall r. r -> c r
    z [a] -> v a
    forall (v :: * -> *) a. Vector v a => [a] -> v a
    fromList)
      Int
    _ -> String -> c (v a)
    forall a. HasCallStack => String -> a
    error String
    "gunfold"

    dataCast :: (Vector v a, Data a, Typeable v, Typeable t)
             => (forall d. Data  d => c (t d)) -> Maybe  (c (v a))
    {-# INLINE dataCast #-}
    dataCast :: 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))
    dataCast forall d. Data d => c (t d)
    f = c (t a) -> Maybe (c (v a))
    forall {k1} {k2} (c :: k1 -> *) (t :: k2 -> k1) (t' :: k2 -> k1)
           (a :: k2).
    (Typeable t, Typeable t') =>
    c (t a) -> Maybe (c (t' a))
    gcast1 c (t a)
    forall d. Data d => c (t d)
    f

    -- $setup
    -- >>> :set -XFlexibleContexts
    -- >>> :set -Wno-type-defaults
    -- >>> import Prelude (Bool(True, False), even, Ord(..))