{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
-- |
-- Module      : Data.Vector.Generic
-- Copyright   : (c) Roman Leshchinskiy 2008-2010
--                   Alexey Kuleshevich 2020-2022
--                   Aleksey Khudyakov 2020-2022
--                   Andrew Lelechenko 2020-2022
-- License     : BSD-style
--
-- Maintainer  : Haskell Libraries Team <libraries@haskell.org>
-- Stability   : experimental
-- Portability : non-portable
--
-- Generic interface to immutable vectors.

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

  -- * Accessors

  -- ** Length information
  length, null,

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

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

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

  -- * Construction

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

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

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

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

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

  -- ** Restricting memory usage
  force,

  -- * Modifying vectors

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

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

  -- ** Permutations
  reverse, backpermute, unsafeBackpermute,

  -- ** Safe destructive updates
  modify,

  -- * Elementwise operations

  -- ** Indexing
  indexed,

  -- ** Mapping
  map, imap, concatMap,

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

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

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

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

  -- * Working with predicates

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

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

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

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

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

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

  -- ** Monadic sequencing
  sequence, sequence_,

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

  -- * Conversions

  -- ** Lists
  toList, fromList, fromListN,

  -- ** Different vector types
  convert,

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

  -- * Fusion support

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

  -- ** Recycling support
  new, clone,

  -- * Utilities

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

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

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

import           Data.Vector.Generic.Base

import qualified Data.Vector.Generic.Mutable as M

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

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

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

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

import Data.Typeable ( Typeable, gcast1 )

#include "vector.h"

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

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

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

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

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

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

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


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

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

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

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

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

{-# RULES

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

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

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

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

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

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

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



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

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

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

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

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

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

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

{-# RULES

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

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

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

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

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

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



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

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

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

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

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

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

-- | /O(1)/ Yield the first @n@ elements paired with the remainder, without copying.
--
-- Note that @'splitAt' n v@ is equivalent to @('take' n v, 'drop' n v)@,
-- but slightly more efficient.
--
-- @since 0.7.1
splitAt :: Vector v a => Int -> v a -> (v a, v a)
{-# INLINE_FUSED splitAt #-}
splitAt :: forall (v :: * -> *) a. Vector v a => Int -> v a -> (v a, v a)
splitAt Int
n v a
v = ( forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
unsafeSlice Int
0 Int
m v a
v
              , forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
unsafeSlice Int
m (forall a b. (a -> b) -> a -> b
delay_inline forall a. Ord a => a -> a -> a
max Int
0 (Int
len forall a. Num a => a -> a -> a
- Int
n')) v a
v
              )
    where
      m :: Int
m   = forall a b. (a -> b) -> a -> b
delay_inline forall a. Ord a => a -> a -> a
min Int
n' Int
len
      n' :: Int
n'  = forall a. Ord a => a -> a -> a
max Int
n Int
0
      len :: Int
len = forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v

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

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

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

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

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

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

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


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

{-# RULES

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

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

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

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

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

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

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



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

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

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

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

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

-- | /O(n)/ Apply the function \(\max(n - 1, 0)\) times to an initial value, producing a vector
-- of length \(\max(n, 0)\). The 0th element will contain the initial value, which is why there
-- is one less function application than the number of elements in the produced vector.
--
-- \( \underbrace{x, f (x), f (f (x)), \ldots}_{\max(0,n)\rm{~elements}} \)
--
-- @since 0.7.1
iterateN :: Vector v a => Int -> (a -> a) -> a -> v a
{-# INLINE iterateN #-}
iterateN :: forall (v :: * -> *) a. Vector v a => Int -> (a -> a) -> a -> v a
iterateN Int
n a -> a
f a
x = forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (forall a (v :: * -> *). Int -> (a -> a) -> a -> Bundle v a
Bundle.iterateN Int
n a -> a
f a
x)

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

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

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

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

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

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

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

-- | /O(n)/ Construct a vector with @n@ elements by repeatedly applying the
-- generator function to the already constructed part of the vector.
--
-- > constructN 3 f = let a = f <> ; b = f <a> ; c = f <a,b> in <a,b,c>
constructN :: forall v a. Vector v a => Int -> (v a -> a) -> v a
{-# INLINE constructN #-}
-- NOTE: We *CANNOT* wrap this in New and then fuse because the elements
-- might contain references to the immutable vector!
constructN :: forall (v :: * -> *) a. Vector v a => Int -> (v a -> a) -> v a
constructN !Int
n v a -> a
f = forall a. (forall s. ST s a) -> a
runST (
  do
    Mutable v s a
v  <- forall (m :: * -> *) (v :: * -> * -> *) a.
(HasCallStack, PrimMonad m, MVector v a) =>
Int -> m (v (PrimState m) a)
M.new Int
n
    v a
v' <- forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
unsafeFreeze Mutable v s a
v
    forall s. v a -> Int -> ST s (v a)
fill v a
v' Int
0
  )
  where
    fill :: forall s. v a -> Int -> ST s (v a)
    fill :: forall s. v a -> Int -> ST s (v a)
fill !v a
v Int
i | Int
i forall a. Ord a => a -> a -> Bool
< Int
n = let x :: a
x = v a -> a
f (forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
unsafeTake Int
i v a
v)
                        in forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
elemseq v a
v a
x forall a b. (a -> b) -> a -> b
$ do
                          Mutable v s a
v'  <- forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
v a -> m (Mutable v (PrimState m) a)
unsafeThaw v a
v
                          forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> Int -> a -> m ()
M.unsafeWrite Mutable v s a
v' Int
i a
x
                          v a
v'' <- forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
unsafeFreeze Mutable v s a
v'
                          forall s. v a -> Int -> ST s (v a)
fill v a
v'' (Int
iforall a. Num a => a -> a -> a
+Int
1)
    fill v a
v Int
_ = forall (m :: * -> *) a. Monad m => a -> m a
return v a
v

-- | /O(n)/ Construct a vector with @n@ elements from right to left by
-- repeatedly applying the generator function to the already constructed part
-- of the vector.
--
-- > constructrN 3 f = let a = f <> ; b = f<a> ; c = f <b,a> in <c,b,a>
constructrN :: forall v a. Vector v a => Int -> (v a -> a) -> v a
{-# INLINE constructrN #-}
-- NOTE: We *CANNOT* wrap this in New and then fuse because the elements
-- might contain references to the immutable vector!
constructrN :: forall (v :: * -> *) a. Vector v a => Int -> (v a -> a) -> v a
constructrN !Int
n v a -> a
f = forall a. (forall s. ST s a) -> a
runST (
  do
    Mutable v s a
v  <- Int
n seq :: forall a b. a -> b -> b
`seq` forall (m :: * -> *) (v :: * -> * -> *) a.
(HasCallStack, PrimMonad m, MVector v a) =>
Int -> m (v (PrimState m) a)
M.new Int
n
    v a
v' <- forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
unsafeFreeze Mutable v s a
v
    forall s. v a -> Int -> ST s (v a)
fill v a
v' Int
0
  )
  where
    fill :: forall s. v a -> Int -> ST s (v a)
    fill :: forall s. v a -> Int -> ST s (v a)
fill !v a
v Int
i | Int
i forall a. Ord a => a -> a -> Bool
< Int
n = let x :: a
x = v a -> a
f (forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
unsafeSlice (Int
nforall a. Num a => a -> a -> a
-Int
i) Int
i v a
v)
                        in forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
elemseq v a
v a
x forall a b. (a -> b) -> a -> b
$ do
                          Mutable v s a
v'  <- forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
v a -> m (Mutable v (PrimState m) a)
unsafeThaw v a
v
                          forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> Int -> a -> m ()
M.unsafeWrite Mutable v s a
v' (Int
nforall a. Num a => a -> a -> a
-Int
iforall a. Num a => a -> a -> a
-Int
1) a
x
                          v a
v'' <- forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
unsafeFreeze Mutable v s a
v'
                          forall s. v a -> Int -> ST s (v a)
fill v a
v'' (Int
iforall a. Num a => a -> a -> a
+Int
1)
    fill v a
v Int
_ = forall (m :: * -> *) a. Monad m => a -> m a
return v a
v


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | /O(n)/ Yield the argument, but force it not to retain any extra memory,
-- possibly by copying it.
--
-- This is especially useful when dealing with slices. For example:
--
-- > force (slice 0 2 <huge vector>)
--
-- Here, the slice retains a reference to the huge vector. Forcing it creates
-- a copy of just the elements that belong to the slice and allows the huge
-- vector to be garbage collected.
force :: Vector v a => v a -> v a
-- FIXME: we probably ought to inline this later as the rules still might fire
-- otherwise
{-# INLINE_FUSED force #-}
force :: forall (v :: * -> *) a. Vector v a => v a -> v a
force v a
v = forall (v :: * -> *) a. Vector v a => New v a -> v a
new (forall (v :: * -> *) a. Vector v a => v a -> New v a
clone v a
v)

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

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

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

-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
-- corresponding value @a@ from the value vector, replace the element of the
-- initial vector at position @i@ by @a@.
--
-- > update_ <5,9,2,7>  <2,0,2> <1,3,8> = <3,9,8,7>
--
-- This function is useful for instances of 'Vector' that cannot store pairs.
-- Otherwise, 'update' is probably more convenient.
--
-- @
-- update_ xs is ys = 'update' xs ('zip' is ys)
-- @
update_ :: (Vector v a, Vector v Int)
        => v a   -- ^ initial vector (of length @m@)
        -> v Int -- ^ index vector (of length @n1@)
        -> v a   -- ^ value vector (of length @n2@)
        -> v a
{-# INLINE update_ #-}
update_ :: forall (v :: * -> *) a.
(Vector v a, Vector v Int) =>
v a -> v Int -> v a -> v a
update_ v a
v v Int
is v a
w = forall (v :: * -> *) a (u :: * -> *).
Vector v a =>
v a -> Bundle u (Int, a) -> v a
update_stream v a
v (forall a b c (v :: * -> *).
(a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
Bundle.zipWith (,) (forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v Int
is) (forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v a
w))

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

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

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

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

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

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

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

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

-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
-- corresponding value @b@ from the the value vector,
-- replace the element of the initial vector at
-- position @i@ by @f a b@.
--
-- > accumulate_ (+) <5,9,2> <2,1,0,1> <4,6,3,7> = <5+3, 9+6+7, 2+4>
--
-- This function is useful for instances of 'Vector' that cannot store pairs.
-- Otherwise, 'accumulate' is probably more convenient:
--
-- @
-- accumulate_ f as is bs = 'accumulate' f as ('zip' is bs)
-- @
accumulate_ :: (Vector v a, Vector v Int, Vector v b)
                => (a -> b -> a) -- ^ accumulating function @f@
                -> v a           -- ^ initial vector (of length @m@)
                -> v Int         -- ^ index vector (of length @n1@)
                -> v b           -- ^ value vector (of length @n2@)
                -> v a
{-# INLINE accumulate_ #-}
accumulate_ :: forall (v :: * -> *) a b.
(Vector v a, Vector v Int, Vector v b) =>
(a -> b -> a) -> v a -> v Int -> v b -> v a
accumulate_ a -> b -> a
f v a
v v Int
is v b
xs = forall (v :: * -> *) a b (u :: * -> *).
Vector v a =>
(a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
accum_stream a -> b -> a
f v a
v (forall a b c (v :: * -> *).
(a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
Bundle.zipWith (,) (forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v Int
is)
                                                             (forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v b
xs))


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

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

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

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

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

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

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

-- | /O(n)/ Yield the vector obtained by replacing each element @i@ of the
-- index vector by @xs'!'i@. This is equivalent to @'map' (xs'!') is@, but is
-- often much more efficient.
--
-- > backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>
backpermute :: forall v a. (HasCallStack, Vector v a, Vector v Int)
            => v a   -- ^ @xs@ value vector
            -> v Int -- ^ @is@ index vector (of length @n@)
            -> v a
{-# INLINE backpermute #-}
-- This somewhat non-intuitive definition ensures that the resulting vector
-- does not retain references to the original one even if it is lazy in its
-- elements. This would not be the case if we simply used map (v!)
backpermute :: forall (v :: * -> *) a.
(HasCallStack, Vector v a, Vector v Int) =>
v a -> v Int -> v a
backpermute v a
v v Int
is = seq :: forall a b. a -> b -> b
seq v a
v
                 forall a b. (a -> b) -> a -> b
$ seq :: forall a b. a -> b -> b
seq Int
n
                 forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream
                 forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a. Bundle v (Box a) -> Bundle v a
Bundle.unbox
                 forall a b. (a -> b) -> a -> b
$ forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
Bundle.map HasCallStack => Int -> Box a
index
                 forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v Int
is
  where
    n :: Int
n = forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | /O(n)/ Drop repeated adjacent elements. The first element in each group is returned.
--
-- ==== __Examples__
--
-- >>> import qualified Data.Vector as V
-- >>> V.uniq $ V.fromList [1,3,3,200,3]
-- [1,3,200,3]
-- >>> import Data.Semigroup
-- >>> V.uniq $ V.fromList [ Arg 1 'a', Arg 1 'b', Arg 1 'c']
-- [Arg 1 'a']
uniq :: (Vector v a, Eq a) => v a -> v a
{-# INLINE uniq #-}
uniq :: forall (v :: * -> *) a. (Vector v a, Eq a) => v a -> v a
uniq = forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace forall a (m :: * -> *). (Eq a, Monad m) => Stream m a -> Stream m a
S.uniq Size -> Size
toMax forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# RULES

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




-- FIXME: make span and break fusible

-- | /O(n)/ Split the vector into the longest prefix of elements that satisfy
-- the predicate and the rest without copying.
span :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
{-# INLINE span #-}
span :: forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> (v a, v a)
span a -> Bool
f = forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> (v a, v a)
break (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
f)

-- | /O(n)/ Split the vector into the longest prefix of elements that do not
-- satisfy the predicate and the rest without copying.
break :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
{-# INLINE break #-}
break :: forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> (v a, v a)
break a -> Bool
f v a
xs = case forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> Maybe Int
findIndex a -> Bool
f v a
xs of
               Just Int
i  -> (forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
unsafeSlice Int
0 Int
i v a
xs, forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
unsafeSlice Int
i (forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
xs forall a. Num a => a -> a -> a
- Int
i) v a
xs)
               Maybe Int
Nothing -> (v a
xs, forall (v :: * -> *) a. Vector v a => v a
empty)

-- | /O(n)/ Split a vector into a list of slices.
--
-- The concatenation of this list of slices is equal to the argument vector,
-- and each slice contains only equal elements, as determined by the equality
-- predicate function.
--
-- >>> import qualified Data.Vector as V
-- >>> import           Data.Char (isUpper)
-- >>> V.groupBy (\a b -> isUpper a == isUpper b) (V.fromList "Mississippi River")
-- ["M","ississippi ","R","iver"]
--
-- See also 'Data.List.groupBy'.
--
-- @since 0.13.0.1
{-# INLINE groupBy #-}
groupBy :: (Vector v a) => (a -> a -> Bool) -> v a -> [v a]
groupBy :: forall (v :: * -> *) a.
Vector v a =>
(a -> a -> Bool) -> v a -> [v a]
groupBy a -> a -> Bool
_ v a
v | forall (v :: * -> *) a. Vector v a => v a -> Bool
null v a
v = []
groupBy a -> a -> Bool
f v a
v =
  let h :: a
h = forall (v :: * -> *) a. Vector v a => v a -> a
unsafeHead v a
v
      tl :: v a
tl = forall (v :: * -> *) a. Vector v a => v a -> v a
unsafeTail v a
v
   in case forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> Maybe Int
findIndex (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> Bool
f a
h) v a
tl of
      Maybe Int
Nothing -> [v a
v]
      Just Int
n -> forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
unsafeTake (Int
n forall a. Num a => a -> a -> a
+ Int
1) v a
v forall a. a -> [a] -> [a]
: forall (v :: * -> *) a.
Vector v a =>
(a -> a -> Bool) -> v a -> [v a]
groupBy a -> a -> Bool
f (forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
unsafeDrop (Int
n forall a. Num a => a -> a -> a
+ Int
1) v a
v)

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

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

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

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

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

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

-- | /O(n)/ Yield 'Just' the index of the /last/ element matching the predicate
-- or 'Nothing' if no such element exists.
--
-- Does not fuse.
--
-- @since 0.12.2.0
findIndexR :: Vector v a => (a -> Bool) -> v a -> Maybe Int
{-# INLINE findIndexR #-}
findIndexR :: forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> Maybe Int
findIndexR a -> Bool
f v a
v = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v forall a. Num a => a -> a -> a
- Int
1 forall a. Num a => a -> a -> a
-) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a (v :: * -> *). (a -> Bool) -> Bundle v a -> Maybe Int
Bundle.findIndex a -> Bool
f forall a b. (a -> b) -> a -> b
$ forall (v :: * -> *) a (u :: * -> *).
Vector v a =>
v a -> Bundle u a
streamR v a
v

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

-- | /O(n)/ Yield the maximum element of the vector according to the
-- given comparison function. The vector may not be empty. In case of
-- a tie, the first occurrence win