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

  -- * Accessors

  -- ** Length information
  length, null,

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

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

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

  -- * Construction

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

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

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

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

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

  -- ** Restricting memory usage
  force,

  -- * Modifying vectors

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

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

  -- ** Permutations
  reverse, backpermute, unsafeBackpermute,

  -- ** Safe destructive updates
  modify,

  -- * Elementwise operations

  -- ** Indexing
  indexed,

  -- ** Mapping
  map, imap, concatMap,

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

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

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

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

  -- * Working with predicates

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

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

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

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

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

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

  -- ** Monadic sequencing
  sequence, sequence_,

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

  -- ** Comparisons
  eqBy, cmpBy,

  -- * Conversions

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

  -- ** Other vector types
  G.convert,

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

type instance G.Mutable Vector = MVector

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | /O(n)/ Construct a vector by repeatedly applying the generator function
-- to a seed. The generator function yields 'Just' the next element and the
-- new seed or 'Nothing' if there are no more elements.
--
-- > unfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10
-- >  = <10,9,8,7,6,5,4,3,2,1>
--
-- @since 0.13.2.0
unfoldr :: (b -> Maybe (a, b)) -> b -> Vector a
{-# INLINE unfoldr #-}
unfoldr :: forall b a. (b -> Maybe (a, b)) -> b -> Vector a
unfoldr = (b -> Maybe (a, b)) -> b -> Vector a
forall (v :: * -> *) a b.
Vector v a =>
(b -> Maybe (a, b)) -> b -> v a
G.unfoldr

-- | /O(n)/ Construct a vector with at most @n@ elements by repeatedly applying
-- the generator function to a seed. The generator function yields 'Just' the
-- next element and the new seed or 'Nothing' if there are no more elements.
--
-- > unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8>
--
-- @since 0.13.2.0
unfoldrN :: Int -> (b -> Maybe (a, b)) -> b -> Vector a
{-# INLINE unfoldrN #-}
unfoldrN :: forall b a. Int -> (b -> Maybe (a, b)) -> b -> Vector a
unfoldrN = Int -> (b -> Maybe (a, b)) -> b -> Vector a
forall (v :: * -> *) a b.
Vector v a =>
Int -> (b -> Maybe (a, b)) -> b -> v a
G.unfoldrN

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

-- | /O(n)/ Construct a vector by repeatedly applying the monadic
-- generator function to a seed. The generator function yields 'Just'
-- the next element and the new seed or 'Nothing' if there are no more
-- elements.
--
-- @since 0.13.2.0
unfoldrM :: (Monad m) => (b -> m (Maybe (a, b))) -> b -> m (Vector a)
{-# INLINE unfoldrM #-}
unfoldrM :: forall (m :: * -> *) b a.
Monad m =>
(b -> m (Maybe (a, b))) -> b -> m (Vector a)
unfoldrM = (b -> m (Maybe (a, b))) -> b -> m (Vector a)
forall (m :: * -> *) (v :: * -> *) a b.
(Monad m, Vector v a) =>
(b -> m (Maybe (a, b))) -> b -> m (v a)
G.unfoldrM

-- | /O(n)/ Construct a vector by repeatedly applying the monadic
-- generator function to a seed. The generator function yields 'Just'
-- the next element and the new seed or 'Nothing' if there are no more
-- elements.
--
-- @since 0.13.2.0
unfoldrNM :: (Monad m) => Int -> (b -> m (Maybe (a, b))) -> b -> m (Vector a)
{-# INLINE unfoldrNM #-}
unfoldrNM :: forall (m :: * -> *) b a.
Monad m =>
Int -> (b -> m (Maybe (a, b))) -> b -> m (Vector a)
unfoldrNM = Int -> (b -> m (Maybe (a, b))) -> b -> m (Vector a)
forall (m :: * -> *) (v :: * -> *) a b.
(Monad m, Vector v a) =>
Int -> (b -> m (Maybe (a, b))) -> b -> m (v a)
G.unfoldrNM

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



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

-- | /O(n)/ Yield the argument, but force it not to retain any extra memory,
-- by copying it.
--
-- This is especially useful when dealing with slices. For example:
--
-- > force (slice 0 2 <huge vector>)
--
-- Here, the slice retains a reference to the huge vector. Forcing it creates
-- a copy of just the elements that belong to the slice and allows the huge
-- vector to be garbage collected.
--
-- @since 0.13.2.0
force :: Vector a -> Vector a
{-# INLINE force #-}
force :: forall a. Vector a -> Vector a
force = Vector a -> Vector a
forall (v :: * -> *) a. Vector v a => v a -> v a
G.force

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | /O(n)/ Split the vector in two parts, the first one containing those
-- elements that satisfy the predicate and the second one those that don't. The
-- relative order of the elements is preserved at the cost of a sometimes
-- reduced performance compared to 'unstablePartition'.
--
-- @since 0.13.2.0
partition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
{-# INLINE partition #-}
partition :: forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
partition = (a -> Bool) -> Vector a -> (Vector a, Vector a)
forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> (v a, v a)
G.partition

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

-- | /O(n)/ Split the vector in two parts, the first one containing those
-- elements that satisfy the predicate and the second one those that don't.
-- The order of the elements is not preserved, but the operation is often
-- faster than 'partition'.
--
-- @since 0.13.2.0
unstablePartition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
{-# INLINE unstablePartition #-}
unstablePartition :: forall a. (a -> Bool) -> Vector a -> (Vector a, Vector a)
unstablePartition = (a -> Bool) -> Vector a -> (Vector a, Vector a)
forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> (v a, v a)
G.unstablePartition

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- Scans
-- -----

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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


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



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

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

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

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

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

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

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

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