{-# LANGUAGE CPP, Rank2Types, MultiParamTypeClasses, FlexibleContexts,
             TypeFamilies, ScopedTypeVariables, BangPatterns #-}
-- |
-- Module      : Data.Vector.Generic
-- Copyright   : (c) Roman Leshchinskiy 2008-2010
-- License     : BSD-style
--
-- Maintainer  : Roman Leshchinskiy <rl@cse.unsw.edu.au>
-- Stability   : experimental
-- Portability : non-portable
--
-- Generic interface to pure 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,
  unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,

  -- * Construction

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

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

  -- ** Unfolding
  unfoldr, unfoldrN,
  unfoldrM, unfoldrNM,
  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_,

  -- ** 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, uniq,
  mapMaybe, imapMaybe,
  filterM,
  takeWhile, dropWhile,

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

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

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

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

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

  -- ** Monadic sequencing
  sequence, sequence_,

  -- * Prefix sums (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, 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 Control.Monad.ST ( ST, runST )
import Control.Monad.Primitive
import Prelude hiding ( length, null,
                        replicate, (++), concat,
                        head, last,
                        init, tail, take, drop, splitAt, reverse,
                        map, concat, concatMap,
                        zipWith, zipWith3, zip, zip3, unzip, unzip3,
                        filter, takeWhile, dropWhile, span, break,
                        elem, notElem,
                        foldl, foldl1, foldr, foldr1,
                        all, any, and, or, sum, product, maximum, minimum,
                        scanl, scanl1, scanr, scanr1,
                        enumFromTo, enumFromThenTo,
                        mapM, mapM_, sequence, sequence_,
                        showsPrec )

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

#if __GLASGOW_HASKELL__ >= 707
import Data.Typeable ( Typeable, gcast1 )
#else
import Data.Typeable ( Typeable1, gcast1 )
#endif

#include "vector.h"

import Data.Data ( Data, DataType, Constr, Fixity(Prefix),
                   mkDataType, mkConstr, constrIndex,
#if MIN_VERSION_base(4,2,0)
                   mkNoRepType )
#else
                   mkNorepType )
#endif
import qualified Data.Traversable as T (Traversable(mapM))

#if !MIN_VERSION_base(4,2,0)
mkNoRepType :: String -> DataType
mkNoRepType = mkNorepType
#endif

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

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

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

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

infixl 9 !
-- | O(1) Indexing
(!) :: Vector v a => v a -> Int -> a
{-# INLINE_FUSED (!) #-}
(!) v :: v a
v i :: Int
i = BOUNDS_CHECK(checkIndex) "(!)" i (length v)
        (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$ Id a -> a
forall a. Id a -> a
unId (v a -> Int -> Id a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
basicUnsafeIndexM v a
v Int
i)

infixl 9 !?
-- | O(1) Safe indexing
(!?) :: Vector v a => v a -> Int -> Maybe a
{-# INLINE_FUSED (!?) #-}
v :: v a
v !? :: v a -> Int -> Maybe a
!? i :: Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0 Bool -> Bool -> Bool
|| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v = Maybe a
forall a. Maybe a
Nothing
       | Bool
otherwise              = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$ v a -> Int -> a
forall (v :: * -> *) a. Vector v a => v a -> Int -> a
unsafeIndex v a
v Int
i

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

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

-- | /O(1)/ Unsafe indexing without bounds checking
unsafeIndex :: Vector v a => v a -> Int -> a
{-# INLINE_FUSED unsafeIndex #-}
unsafeIndex :: v a -> Int -> a
unsafeIndex v :: v a
v i :: Int
i = UNSAFE_CHECK(checkIndex) "unsafeIndex" i (length v)
                (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$ Id a -> a
forall a. Id a -> a
unId (v a -> Int -> Id a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m 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 :: v a -> a
unsafeHead v :: v a
v = v a -> Int -> a
forall (v :: * -> *) a. Vector v a => v a -> Int -> a
unsafeIndex v a
v 0

-- | /O(1)/ Last element without checking if the vector is empty
unsafeLast :: Vector v a => v a -> a
{-# INLINE_FUSED unsafeLast #-}
unsafeLast :: v a -> a
unsafeLast v :: v a
v = v a -> Int -> a
forall (v :: * -> *) a. Vector v a => v a -> Int -> a
unsafeIndex v a
v (v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- 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
-- elements) is evaluated eagerly.
--
indexM :: (Vector v a, Monad m) => v a -> Int -> m a
{-# INLINE_FUSED indexM #-}
indexM :: v a -> Int -> m a
indexM v :: v a
v i :: Int
i = BOUNDS_CHECK(checkIndex) "indexM" i (length v)
           (m a -> m a) -> m a -> m a
forall a b. (a -> b) -> a -> b
$ v a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m 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 :: v a -> m a
headM v :: v a
v = v a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
indexM v a
v 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 :: v a -> m a
lastM v :: v a
v = v a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
indexM v a
v (v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- 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 :: v a -> Int -> m a
unsafeIndexM v :: v a
v i :: Int
i = UNSAFE_CHECK(checkIndex) "unsafeIndexM" i (length v)
                 (m a -> m a) -> m a -> m a
forall a b. (a -> b) -> a -> b
$ v a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m 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 :: v a -> m a
unsafeHeadM v :: v a
v = v a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
unsafeIndexM v a
v 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 :: v a -> m a
unsafeLastM v :: v a
v = v a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
unsafeIndexM v a
v (v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- 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 :: Vector v a => Int   -- ^ @i@ starting index
                    -> Int   -- ^ @n@ length
                    -> v a
                    -> v a
{-# INLINE_FUSED slice #-}
slice :: Int -> Int -> v a -> v a
slice i :: Int
i n :: Int
n v :: v a
v = BOUNDS_CHECK(checkSlice) "slice" i n (length v)
            (v a -> v a) -> v a -> v a
forall a b. (a -> b) -> a -> b
$ Int -> Int -> v a -> v a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
basicUnsafeSlice Int
i Int
n v a
v

-- | /O(1)/ Yield all but the last element without copying. The vector may not
-- be empty.
init :: Vector v a => v a -> v a
{-# INLINE_FUSED init #-}
init :: v a -> v a
init v :: v a
v = Int -> Int -> v a -> v a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
slice 0 (v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- 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 :: v a -> v a
tail v :: v a
v = Int -> Int -> v a -> v a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
slice 1 (v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- 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 :: Int -> v a -> v a
take n :: Int
n v :: v a
v = Int -> Int -> v a -> v a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
unsafeSlice 0 ((Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
delay_inline Int -> Int -> Int
forall a. Ord a => a -> a -> a
min Int
n' (v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v)) v a
v
  where n' :: Int
n' = Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
n 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 :: Int -> v a -> v a
drop n :: Int
n v :: v a
v = Int -> Int -> v a -> v a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
unsafeSlice ((Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
delay_inline Int -> Int -> Int
forall a. Ord a => a -> a -> a
min Int
n' Int
len)
                       ((Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
delay_inline Int -> Int -> Int
forall a. Ord a => a -> a -> a
max 0 (Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
n')) v a
v
  where n' :: Int
n' = Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
n 0
        len :: Int
len = v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v

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

-- | /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 :: Int -> Int -> v a -> v a
unsafeSlice i :: Int
i n :: Int
n v :: v a
v = UNSAFE_CHECK(checkSlice) "unsafeSlice" i n (length v)
                  (v a -> v a) -> v a -> v a
forall a b. (a -> b) -> a -> b
$ Int -> Int -> v a -> v a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
basicUnsafeSlice Int
i Int
n v a
v

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


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

{-# RULES

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

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

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

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

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

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

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



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

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

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

-- | /O(n)/ 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 :: Int -> a -> v a
replicate n :: Int
n x :: a
x = v a -> a -> v a -> v a
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
elemseq (v a
forall a. HasCallStack => a
undefined :: v a) a
x
              (v a -> v a) -> v a -> v a
forall a b. (a -> b) -> a -> b
$ Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream
              (Bundle v a -> v a) -> Bundle v a -> v a
forall a b. (a -> b) -> a -> b
$ Int -> a -> Bundle v a
forall a (v :: * -> *). Int -> a -> Bundle v a
Bundle.replicate Int
n a
x

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

-- | /O(n)/ Apply function n times to value. Zeroth element is original value.
iterateN :: Vector v a => Int -> (a -> a) -> a -> v a
{-# INLINE iterateN #-}
iterateN :: Int -> (a -> a) -> a -> v a
iterateN n :: Int
n f :: a -> a
f x :: a
x = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Int -> (a -> a) -> a -> Bundle v a
forall a (v :: * -> *). Int -> (a -> a) -> a -> Bundle v a
Bundle.iterateN Int
n a -> a
f a
x)

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

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

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

-- | /O(n)/ Construct a vector 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 :: (b -> m (Maybe (a, b))) -> b -> m (v a)
unfoldrM f :: b -> m (Maybe (a, b))
f = MBundle m Any a -> m (v a)
forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
(Monad m, Vector v a) =>
MBundle m u a -> m (v a)
unstreamM (MBundle m Any a -> m (v a))
-> (b -> MBundle m Any a) -> b -> m (v a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> m (Maybe (a, b))) -> b -> MBundle m Any a
forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
(s -> m (Maybe (a, s))) -> s -> Bundle m u a
MBundle.unfoldrM b -> m (Maybe (a, b))
f

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

-- | /O(n)/ Construct a vector with @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 :: Int -> (v a -> a) -> v a
constructN !Int
n f :: v a -> a
f = (forall s. ST s (v a)) -> v a
forall a. (forall s. ST s a) -> a
runST (
  do
    Mutable v s a
v  <- Int -> ST s (Mutable v (PrimState (ST s)) a)
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
Int -> m (v (PrimState m) a)
M.new Int
n
    v a
v' <- Mutable v (PrimState (ST s)) a -> ST s (v a)
forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
unsafeFreeze Mutable v s a
Mutable v (PrimState (ST s)) a
v
    v a -> Int -> ST s (v a)
forall s. v a -> Int -> ST s (v a)
fill v a
v' 0
  )
  where
    fill :: forall s. v a -> Int -> ST s (v a)
    fill :: v a -> Int -> ST s (v a)
fill !v a
v i :: Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n = let x :: a
x = v a -> a
f (Int -> v a -> v a
forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
unsafeTake Int
i v a
v)
                        in
                        v a -> a -> ST s (v a) -> ST s (v a)
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
elemseq v a
v a
x (ST s (v a) -> ST s (v a)) -> ST s (v a) -> ST s (v a)
forall a b. (a -> b) -> a -> b
$
                        do
                          Mutable v s a
v'  <- v a -> ST s (Mutable v (PrimState (ST s)) a)
forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
v a -> m (Mutable v (PrimState m) a)
unsafeThaw v a
v
                          Mutable v (PrimState (ST s)) a -> Int -> a -> ST s ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> Int -> a -> m ()
M.unsafeWrite Mutable v s a
Mutable v (PrimState (ST s)) a
v' Int
i a
x
                          v a
v'' <- Mutable v (PrimState (ST s)) a -> ST s (v a)
forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
unsafeFreeze Mutable v s a
Mutable v (PrimState (ST s)) a
v'
                          v a -> Int -> ST s (v a)
forall s. v a -> Int -> ST s (v a)
fill v a
v'' (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+1)

    fill v :: v a
v _ = v a -> ST s (v a)
forall (m :: * -> *) a. Monad m => a -> m a
return v a
v

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

    fill v :: v a
v _ = v a -> ST s (v a)
forall (m :: * -> *) a. Monad m => a -> m a
return v a
v


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

-- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+1@
-- etc. This operation is usually more efficient than 'enumFromTo'.
--
-- > enumFromN 5 3 = <5,6,7>
enumFromN :: (Vector v a, Num a) => a -> Int -> v a
{-# INLINE enumFromN #-}
enumFromN :: a -> Int -> v a
enumFromN x :: a
x n :: Int
n = a -> a -> Int -> v a
forall (v :: * -> *) a. (Vector v a, Num a) => a -> a -> Int -> v a
enumFromStepN a
x 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 0.1 5 = <1,1.1,1.2,1.3,1.4>
enumFromStepN :: forall v a. (Vector v a, Num a) => a -> a -> Int -> v a
{-# INLINE enumFromStepN #-}
enumFromStepN :: a -> a -> Int -> v a
enumFromStepN x :: a
x y :: a
y n :: Int
n = v a -> a -> v a -> v a
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
elemseq (v a
forall a. HasCallStack => a
undefined :: v a) a
x
                    (v a -> v a) -> v a -> v a
forall a b. (a -> b) -> a -> b
$ v a -> a -> v a -> v a
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
elemseq (v a
forall a. HasCallStack => a
undefined :: v a) a
y
                    (v a -> v a) -> v a -> v a
forall a b. (a -> b) -> a -> b
$ Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream
                    (Bundle v a -> v a) -> Bundle v a -> v a
forall a b. (a -> b) -> a -> b
$ a -> a -> Int -> Bundle v a
forall a (v :: * -> *). Num a => a -> a -> Int -> Bundle v a
Bundle.enumFromStepN  a
x a
y Int
n

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | /O(n)/ Apply monadic function n times to value. Zeroth element is original value.
iterateNM :: (Monad m, Vector v a) => Int -> (a -> m a) -> a -> m (v a)
{-# INLINE iterateNM #-}
iterateNM :: Int -> (a -> m a) -> a -> m (v a)
iterateNM n :: Int
n f :: a -> m a
f x :: a
x = MBundle m Any a -> m (v a)
forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
(Monad m, Vector v a) =>
MBundle m u a -> m (v a)
unstreamM (Int -> (a -> m a) -> a -> MBundle m Any a
forall (m :: * -> *) a (u :: * -> *).
Monad m =>
Int -> (a -> m a) -> a -> Bundle m u a
MBundle.iterateNM Int
n a -> m a
f a
x)

-- | Execute the monadic action and freeze the resulting vector.
--
-- @
-- create (do { v \<- 'M.new' 2; 'M.write' v 0 \'a\'; 'M.write' v 1 \'b\'; return v }) = \<'a','b'\>
-- @
create :: Vector v a => (forall s. ST s (Mutable v s a)) -> v a
{-# INLINE create #-}
create :: (forall s. ST s (Mutable v s a)) -> v a
create p :: forall s. ST s (Mutable v s a)
p = New v a -> v a
forall (v :: * -> *) a. Vector v a => New v a -> v a
new ((forall s. ST s (Mutable v s a)) -> New v a
forall (v :: * -> *) a. (forall s. ST s (Mutable v s a)) -> New v a
New.create 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 s. ST s (f (Mutable v s a))) -> f (v a)
createT p :: forall s. ST s (f (Mutable v s a))
p = (forall s. ST s (f (v a))) -> f (v a)
forall a. (forall s. ST s a) -> a
runST (ST s (f (Mutable v s a))
forall s. ST s (f (Mutable v s a))
p ST s (f (Mutable v s a))
-> (f (Mutable v s a) -> ST s (f (v a))) -> ST s (f (v a))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Mutable v s a -> ST s (v a))
-> f (Mutable v s a) -> ST s (f (v a))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
T.mapM Mutable v s a -> ST s (v a)
forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
unsafeFreeze)

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

-- | /O(n)/ Yield the argument but force it not to retain any extra memory,
-- 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 :: v a -> v a
force v :: v a
v = New v a -> v a
forall (v :: * -> *) a. Vector v a => New v a -> v a
new (v a -> New v a
forall (v :: * -> *) a. Vector v a => v a -> New v a
clone v a
v)

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

-- | /O(m+n)/ For each pair @(i,a)@ from the list, 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 :: v a
v // :: v a -> [(Int, a)] -> v a
// us :: [(Int, a)]
us = v a -> Bundle Any (Int, a) -> v a
forall (v :: * -> *) a (u :: * -> *).
Vector v a =>
v a -> Bundle u (Int, a) -> v a
update_stream v a
v ([(Int, a)] -> Bundle Any (Int, a)
forall a (v :: * -> *). [a] -> Bundle v a
Bundle.fromList [(Int, a)]
us)

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

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

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

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

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

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

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

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

-- | /O(m+n)/ For each pair @(i,b)@ from the list, replace the vector element
-- @a@ at position @i@ by @f a b@.
--
-- > accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>
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 :: (a -> b -> a) -> v a -> [(Int, b)] -> v a
accum f :: a -> b -> a
f v :: v a
v us :: [(Int, b)]
us = (a -> b -> a) -> v a -> Bundle Any (Int, b) -> v a
forall (v :: * -> *) a b (u :: * -> *).
Vector v a =>
(a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
accum_stream a -> b -> a
f v a
v ([(Int, b)] -> Bundle Any (Int, b)
forall a (v :: * -> *). [a] -> Bundle v a
Bundle.fromList [(Int, b)]
us)

-- | /O(m+n)/ For each pair @(i,b)@ from the vector of pairs, replace the vector
-- element @a@ at position @i@ by @f a b@.
--
-- > accumulate (+) <5,9,2> <(2,4),(1,6),(0,3),(1,7)> = <5+3, 9+6+7, 2+4>
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 :: (a -> b -> a) -> v a -> v (Int, b) -> v a
accumulate f :: a -> b -> a
f v :: v a
v us :: v (Int, b)
us = (a -> b -> a) -> v a -> Bundle v (Int, b) -> v a
forall (v :: * -> *) a b (u :: * -> *).
Vector v a =>
(a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
accum_stream a -> b -> a
f v a
v (v (Int, b) -> Bundle v (Int, b)
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v (Int, b)
us)

-- | /O(m+min(n1,n2))/ For each index @i@ from the index vector and the
-- corresponding value @b@ from the 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_ :: (a -> b -> a) -> v a -> v Int -> v b -> v a
accumulate_ f :: a -> b -> a
f v :: v a
v is :: v Int
is xs :: v b
xs = (a -> b -> a) -> v a -> Bundle v (Int, b) -> v a
forall (v :: * -> *) a b (u :: * -> *).
Vector v a =>
(a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
accum_stream a -> b -> a
f v a
v ((Int -> b -> (Int, b))
-> Bundle v Int -> Bundle v b -> Bundle v (Int, b)
forall a b c (v :: * -> *).
(a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
Bundle.zipWith (,) (v Int -> Bundle v Int
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v Int
is)
                                                             (v b -> Bundle v b
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v b
xs))


accum_stream :: Vector v a => (a -> b -> a) -> v a -> Bundle u (Int,b) -> v a
{-# INLINE accum_stream #-}
accum_stream :: (a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
accum_stream f :: a -> b -> a
f = (forall s. Mutable v s a -> Bundle u (Int, b) -> ST s ())
-> v a -> Bundle u (Int, b) -> v a
forall (v :: * -> *) a (u :: * -> *) b.
Vector v a =>
(forall s. Mutable v s a -> Bundle u b -> ST s ())
-> v a -> Bundle u b -> v a
modifyWithBundle ((a -> b -> a)
-> Mutable v (PrimState (ST s)) a -> Bundle u (Int, b) -> ST s ()
forall (m :: * -> *) (v :: * -> * -> *) a b (u :: * -> *).
(PrimMonad m, MVector v a) =>
(a -> b -> a) -> v (PrimState m) a -> Bundle u (Int, b) -> m ()
M.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 :: (a -> b -> a) -> v a -> [(Int, b)] -> v a
unsafeAccum f :: a -> b -> a
f v :: v a
v us :: [(Int, b)]
us = (a -> b -> a) -> v a -> Bundle Any (Int, b) -> v a
forall (v :: * -> *) a b (u :: * -> *).
Vector v a =>
(a -> b -> a) -> v a -> Bundle u (Int, b) -> v a
unsafeAccum_stream a -> b -> a
f v a
v ([(Int, b)] -> Bundle Any (Int, b)
forall a (v :: * -> *). [a] -> Bundle v a
Bundle.fromList [(Int, b)]
us)

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

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

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

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

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

-- | /O(n)/ Yield the vector obtained by replacing each element @i@ of the
-- index vector by @xs'!'i@. This is equivalent to @'map' (xs'!') is@ but is
-- often much more efficient.
--
-- > backpermute <a,b,c,d> <0,3,2,3,1,0> = <a,d,c,d,b,a>
backpermute :: (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 :: v a -> v Int -> v a
backpermute v :: v a
v is :: v Int
is = v a -> v a -> v a
forall a b. a -> b -> b
seq v a
v
                 (v a -> v a) -> v a -> v a
forall a b. (a -> b) -> a -> b
$ Int -> v a -> v a
forall a b. a -> b -> b
seq Int
n
                 (v a -> v a) -> v a -> v a
forall a b. (a -> b) -> a -> b
$ Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream
                 (Bundle v a -> v a) -> Bundle v a -> v a
forall a b. (a -> b) -> a -> b
$ Bundle v (Box a) -> Bundle v a
forall (v :: * -> *) a. Bundle v (Box a) -> Bundle v a
Bundle.unbox
                 (Bundle v (Box a) -> Bundle v a) -> Bundle v (Box a) -> Bundle v a
forall a b. (a -> b) -> a -> b
$ (Int -> Box a) -> Bundle v Int -> Bundle v (Box a)
forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
Bundle.map Int -> Box a
index
                 (Bundle v Int -> Bundle v (Box a))
-> Bundle v Int -> Bundle v (Box a)
forall a b. (a -> b) -> a -> b
$ v Int -> Bundle v Int
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v Int
is
  where
    n :: Int
n = v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v

    {-# INLINE index #-}
    -- NOTE: we do it this way to avoid triggering LiberateCase on n in
    -- polymorphic code
    index :: Int -> Box a
index i :: Int
i = BOUNDS_CHECK(checkIndex) "backpermute" i n
            (Box a -> Box a) -> Box a -> Box a
forall a b. (a -> b) -> a -> b
$ v a -> Int -> Box a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m 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 :: v a -> v Int -> v a
unsafeBackpermute v :: v a
v is :: v Int
is = v a -> v a -> v a
forall a b. a -> b -> b
seq v a
v
                       (v a -> v a) -> v a -> v a
forall a b. (a -> b) -> a -> b
$ Int -> v a -> v a
forall a b. a -> b -> b
seq Int
n
                       (v a -> v a) -> v a -> v a
forall a b. (a -> b) -> a -> b
$ Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream
                       (Bundle v a -> v a) -> Bundle v a -> v a
forall a b. (a -> b) -> a -> b
$ Bundle v (Box a) -> Bundle v a
forall (v :: * -> *) a. Bundle v (Box a) -> Bundle v a
Bundle.unbox
                       (Bundle v (Box a) -> Bundle v a) -> Bundle v (Box a) -> Bundle v a
forall a b. (a -> b) -> a -> b
$ (Int -> Box a) -> Bundle v Int -> Bundle v (Box a)
forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
Bundle.map Int -> Box a
index
                       (Bundle v Int -> Bundle v (Box a))
-> Bundle v Int -> Bundle v (Box a)
forall a b. (a -> b) -> a -> b
$ v Int -> Bundle v Int
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v Int
is
  where
    n :: Int
n = v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
length v a
v

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

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

-- | Apply a destructive operation to a vector. The operation will be
-- performed in place if it is safe to do so and will modify a copy of the
-- vector otherwise.
--
-- @
-- modify (\\v -> 'M.write' v 0 \'x\') ('replicate' 3 \'a\') = \<\'x\',\'a\',\'a\'\>
-- @
modify :: Vector v a => (forall s. Mutable v s a -> ST s ()) -> v a -> v a
{-# INLINE modify #-}
modify :: (forall s. Mutable v s a -> ST s ()) -> v a -> v a
modify p :: forall s. Mutable v s a -> ST s ()
p = New v a -> v a
forall (v :: * -> *) a. Vector v a => New v a -> v a
new (New v a -> v a) -> (v a -> New v a) -> v a -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall s. Mutable v s a -> ST s ()) -> New v a -> New v a
forall (v :: * -> *) a.
(forall s. Mutable v s a -> ST s ()) -> New v a -> New v a
New.modify forall s. Mutable v s a -> ST s ()
p (New v a -> New v a) -> (v a -> New v a) -> v a -> New v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> New v a
forall (v :: * -> *) a. Vector v a => v a -> New v a
clone

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- 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 :: (a -> b -> c) -> v a -> v b -> v c
zipWith f :: a -> b -> c
f = \xs :: v a
xs ys :: v b
ys -> Bundle v c -> v c
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream ((a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
forall a b c (v :: * -> *).
(a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
Bundle.zipWith a -> b -> c
f (v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v a
xs) (v b -> Bundle v b
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v b
ys))

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

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

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

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

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

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 :: (Int -> a -> b -> c -> d) -> v a -> v b -> v c -> v d
izipWith3 f :: Int -> a -> b -> c -> d
f = \as :: v a
as bs :: v b
bs cs :: v c
cs ->
    Bundle v d -> v d
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (((Int, a) -> b -> c -> d)
-> Bundle v (Int, a) -> Bundle v b -> Bundle v c -> Bundle v d
forall a b c d (v :: * -> *).
(a -> b -> c -> d)
-> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d
Bundle.zipWith3 ((Int -> a -> b -> c -> d) -> (Int, a) -> b -> c -> d
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int -> a -> b -> c -> d
f) (Bundle v a -> Bundle v (Int, a)
forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
Bundle.indexed (v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v a
as))
                                                          (v b -> Bundle v b
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v b
bs)
                                                          (v c -> Bundle v c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v c
cs))

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

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

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

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

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 :: v a -> v b -> v c -> v (a, b, c)
zip3 = (a -> b -> c -> (a, b, c)) -> v a -> v b -> v c -> v (a, b, c)
forall (v :: * -> *) a b c d.
(Vector v a, Vector v b, Vector v c, Vector v d) =>
(a -> b -> c -> d) -> v a -> v b -> v c -> v d
zipWith3 (,,)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | /O(n)/ Drop repeated adjacent elements.
uniq :: (Vector v a, Eq a) => v a -> v a
{-# INLINE uniq #-}
uniq :: v a -> v a
uniq = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
-> (Size -> Size) -> Bundle v a -> Bundle v a
forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace forall a (m :: * -> *). (Eq a, Monad m) => Stream m a -> Stream m a
forall (m :: * -> *). Monad m => Stream m a -> Stream m a
S.uniq Size -> Size
toMax (Bundle v a -> Bundle v a)
-> (v a -> Bundle v a) -> v a -> Bundle v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Drop elements when predicate returns Nothing
mapMaybe :: (Vector v a, Vector v b) => (a -> Maybe b) -> v a -> v b
{-# INLINE mapMaybe #-}
mapMaybe :: (a -> Maybe b) -> v a -> v b
mapMaybe f :: a -> Maybe b
f = Bundle v b -> v b
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace ((a -> Maybe b) -> Stream m a -> Stream m b
forall (m :: * -> *) a b.
Monad m =>
(a -> Maybe b) -> Stream m a -> Stream m b
S.mapMaybe a -> Maybe b
f) Size -> Size
toMax (Bundle v a -> Bundle v b)
-> (v a -> Bundle v a) -> v a -> Bundle v b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Drop elements when predicate, applied to index and value, returns Nothing
imapMaybe :: (Vector v a, Vector v b) => (Int -> a -> Maybe b) -> v a -> v b
{-# INLINE imapMaybe #-}
imapMaybe :: (Int -> a -> Maybe b) -> v a -> v b
imapMaybe f :: Int -> a -> Maybe b
f = Bundle v b -> v b
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream
          (Bundle v b -> v b) -> (v a -> Bundle v b) -> v a -> v b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace (((Int, a) -> Maybe b) -> Stream m (Int, a) -> Stream m b
forall (m :: * -> *) a b.
Monad m =>
(a -> Maybe b) -> Stream m a -> Stream m b
S.mapMaybe ((Int -> a -> Maybe b) -> (Int, a) -> Maybe b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int -> a -> Maybe b
f) (Stream m (Int, a) -> Stream m b)
-> (Stream m a -> Stream m (Int, a)) -> Stream m a -> Stream m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stream m a -> Stream m (Int, a)
forall (m :: * -> *) a. Monad m => Stream m a -> Stream m (Int, a)
S.indexed) Size -> Size
toMax
          (Bundle v a -> Bundle v b)
-> (v a -> Bundle v a) -> v a -> Bundle v b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream


-- | /O(n)/ Drop 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 :: (a -> m Bool) -> v a -> m (v a)
filterM f :: a -> m Bool
f = MBundle m v a -> m (v a)
forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
(Monad m, Vector v a) =>
MBundle m u a -> m (v a)
unstreamM (MBundle m v a -> m (v a))
-> (v a -> MBundle m v a) -> v a -> m (v a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> m Bool) -> Bundle v a -> MBundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle v a -> Bundle m v a
Bundle.filterM a -> m Bool
f (Bundle v a -> MBundle m v a)
-> (v a -> Bundle v a) -> v a -> MBundle m v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Yield the longest prefix of elements satisfying the predicate
-- without copying.
takeWhile :: Vector v a => (a -> Bool) -> v a -> v a
{-# INLINE takeWhile #-}
takeWhile :: (a -> Bool) -> v a -> v a
takeWhile f :: a -> Bool
f = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> Bundle v a -> Bundle v a
forall a (v :: * -> *). (a -> Bool) -> Bundle v a -> Bundle v a
Bundle.takeWhile a -> Bool
f (Bundle v a -> Bundle v a)
-> (v a -> Bundle v a) -> v a -> Bundle v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Drop the longest prefix of elements that satisfy the predicate
-- without copying.
dropWhile :: Vector v a => (a -> Bool) -> v a -> v a
{-# INLINE dropWhile #-}
dropWhile :: (a -> Bool) -> v a -> v a
dropWhile f :: a -> Bool
f = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> Bundle v a -> Bundle v a
forall a (v :: * -> *). (a -> Bool) -> Bundle v a -> Bundle v a
Bundle.dropWhile a -> Bool
f (Bundle v a -> Bundle v a)
-> (v a -> Bundle v a) -> v a -> Bundle v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

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

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

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

partitionWith :: (Vector v a, Vector v b, Vector v c) => (a -> Either b c) -> v a -> (v b, v c)
{-# INLINE partitionWith #-}
partitionWith :: (a -> Either b c) -> v a -> (v b, v c)
partitionWith f :: a -> Either b c
f = (a -> Either b c) -> Bundle v a -> (v b, v c)
forall (v :: * -> *) a b c (u :: * -> *).
(Vector v a, Vector v b, Vector v c) =>
(a -> Either b c) -> Bundle u a -> (v b, v c)
partition_with_stream a -> Either b c
f (Bundle v a -> (v b, v c))
-> (v a -> Bundle v a) -> v a -> (v b, v c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

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

unstablePartition_stream
  :: Vector v a => (a -> Bool) -> Bundle u a -> (v a, v a)
{-# INLINE_FUSED unstablePartition_stream #-}
unstablePartition_stream :: (a -> Bool) -> Bundle u a -> (v a, v a)
unstablePartition_stream f :: a -> Bool
f s :: Bundle u a
s = Bundle u a
s Bundle u a -> (v a, v a) -> (v a, v a)
forall a b. a -> b -> b
`seq` (forall s. ST s (v a, v a)) -> (v a, v a)
forall a. (forall s. ST s a) -> a
runST (
  do
    (mv1 :: Mutable v s a
mv1,mv2 :: Mutable v s a
mv2) <- (a -> Bool)
-> Bundle u a
-> ST
     s (Mutable v (PrimState (ST s)) a, Mutable v (PrimState (ST s)) a)
forall (m :: * -> *) (v :: * -> * -> *) a (u :: * -> *).
(PrimMonad m, MVector v a) =>
(a -> Bool)
-> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a)
M.unstablePartitionBundle a -> Bool
f Bundle u a
s
    v a
v1 <- Mutable v (PrimState (ST s)) a -> ST s (v a)
forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
unsafeFreeze Mutable v s a
Mutable v (PrimState (ST s)) a
mv1
    v a
v2 <- Mutable v (PrimState (ST s)) a -> ST s (v a)
forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
unsafeFreeze Mutable v s a
Mutable v (PrimState (ST s)) a
mv2
    (v a, v a) -> ST s (v a, v a)
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 :: (a -> Bool) -> New v a -> (v a, v a)
unstablePartition_new f :: a -> Bool
f (New.New p :: forall s. ST s (Mutable v s a)
p) = (forall s. ST s (v a, v a)) -> (v a, v a)
forall a. (forall s. ST s a) -> a
runST (
  do
    Mutable v s a
mv <- ST s (Mutable v s a)
forall s. ST s (Mutable v s a)
p
    Int
i <- (a -> Bool) -> Mutable v (PrimState (ST s)) a -> ST s Int
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
Mutable v (PrimState (ST s)) a
mv
    v a
v <- Mutable v (PrimState (ST s)) a -> ST s (v a)
forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
unsafeFreeze Mutable v s a
Mutable v (PrimState (ST s)) a
mv
    (v a, v a) -> ST s (v a, v a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> v a -> v a
forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
unsafeTake Int
i v a
v, Int -> v a -> v a
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 :: (a -> Bool) -> v a -> (v a, v a)
span f :: a -> Bool
f = (a -> Bool) -> v a -> (v a, v a)
forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> (v a, v a)
break (Bool -> Bool
not (Bool -> Bool) -> (a -> Bool) -> a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
f)

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


-- 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 :: a -> v a -> Bool
elem x :: a
x = a -> Bundle v a -> Bool
forall a (v :: * -> *). Eq a => a -> Bundle v a -> Bool
Bundle.elem a
x (Bundle v a -> Bool) -> (v a -> Bundle v a) -> v a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

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

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

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

-- | /O(n)/ Yield 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 :: (a -> Bool) -> v a -> v Int
findIndices f :: a -> Bool
f = Bundle v Int -> v Int
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream
              (Bundle v Int -> v Int) -> (v a -> Bundle v Int) -> v a -> v Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (m :: * -> *). Monad m => Stream m a -> Stream m Int)
-> (Size -> Size) -> Bundle v a -> Bundle v Int
forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace (((Int, a) -> Int) -> Stream m (Int, a) -> Stream m Int
forall (m :: * -> *) a b.
Monad m =>
(a -> b) -> Stream m a -> Stream m b
S.map (Int, a) -> Int
forall a b. (a, b) -> a
fst (Stream m (Int, a) -> Stream m Int)
-> (Stream m a -> Stream m (Int, a)) -> Stream m a -> Stream m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Int, a) -> Bool) -> Stream m (Int, a) -> Stream m (Int, a)
forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Stream m a -> Stream m a
S.filter (a -> Bool
f (a -> Bool) -> ((Int, a) -> a) -> (Int, a) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, a) -> a
forall a b. (a, b) -> b
snd) (Stream m (Int, a) -> Stream m (Int, a))
-> (Stream m a -> Stream m (Int, a))
-> Stream m a
-> Stream m (Int, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Stream m a -> Stream m (Int, a)
forall (m :: * -> *) a. Monad m => Stream m a -> Stream m (Int, a)
S.indexed) Size -> Size
toMax
              (Bundle v a -> Bundle v Int)
-> (v a -> Bundle v a) -> v a -> Bundle v Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Yield 'Just' the index of the first occurence 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 :: a -> v a -> Maybe Int
elemIndex x :: a
x = (a -> Bool) -> v a -> Maybe Int
forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> Maybe Int
findIndex (a
xa -> a -> Bool
forall a. Eq a => a -> a -> Bool
==)

-- | /O(n)/ Yield the indices of all occurences 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 :: a -> v a -> v Int
elemIndices x :: a
x = (a -> Bool) -> v a -> v Int
forall (v :: * -> *) a.
(Vector v a, Vector v Int) =>
(a -> Bool) -> v a -> v Int
findIndices (a
xa -> a -> Bool
forall a. Eq a => a -> a -> Bool
==)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | /O(n)/ Check if all elements satisfy the predicate.
all :: Vector v a => (a -> Bool) -> v a -> Bool
{-# INLINE all #-}
all :: (a -> Bool) -> v a -> Bool
all f :: a -> Bool
f = Bundle v Bool -> Bool
forall (v :: * -> *). Bundle v Bool -> Bool
Bundle.and (Bundle v Bool -> Bool) -> (v a -> Bundle v Bool) -> v a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> Bundle v a -> Bundle v Bool
forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
Bundle.map a -> Bool
f (Bundle v a -> Bundle v Bool)
-> (v a -> Bundle v a) -> v a -> Bundle v Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Check if any element satisfies the predicate.
any :: Vector v a => (a -> Bool) -> v a -> Bool
{-# INLINE any #-}
any :: (a -> Bool) -> v a -> Bool
any f :: a -> Bool
f = Bundle v Bool -> Bool
forall (v :: * -> *). Bundle v Bool -> Bool
Bundle.or (Bundle v Bool -> Bool) -> (v a -> Bundle v Bool) -> v a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> Bundle v a -> Bundle v Bool
forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
Bundle.map a -> Bool
f (Bundle v a -> Bundle v Bool)
-> (v a -> Bundle v a) -> v a -> Bundle v Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Check if all elements are 'True'
and :: Vector v Bool => v Bool -> Bool
{-# INLINE and #-}
and :: v Bool -> Bool
and = Bundle v Bool -> Bool
forall (v :: * -> *). Bundle v Bool -> Bool
Bundle.and (Bundle v Bool -> Bool)
-> (v Bool -> Bundle v Bool) -> v Bool -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v Bool -> Bundle v Bool
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Check if any element is 'True'
or :: Vector v Bool => v Bool -> Bool
{-# INLINE or #-}
or :: v Bool -> Bool
or = Bundle v Bool -> Bool
forall (v :: * -> *). Bundle v Bool -> Bool
Bundle.or (Bundle v Bool -> Bool)
-> (v Bool -> Bundle v Bool) -> v Bool -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v Bool -> Bundle v Bool
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Compute the sum of the elements
sum :: (Vector v a, Num a) => v a -> a
{-# INLINE sum #-}
sum :: v a -> a
sum = (a -> a -> a) -> a -> Bundle v a -> a
forall a b (v :: * -> *). (a -> b -> a) -> a -> Bundle v b -> a
Bundle.foldl' a -> a -> a
forall a. Num a => a -> a -> a
(+) 0 (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Compute the produce of the elements
product :: (Vector v a, Num a) => v a -> a
{-# INLINE product #-}
product :: v a -> a
product = (a -> a -> a) -> a -> Bundle v a -> a
forall a b (v :: * -> *). (a -> b -> a) -> a -> Bundle v b -> a
Bundle.foldl' a -> a -> a
forall a. Num a => a -> a -> a
(*) 1 (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Yield the maximum element of the vector. The vector may not be
-- empty.
maximum :: (Vector v a, Ord a) => v a -> a
{-# INLINE maximum #-}
maximum :: v a -> a
maximum = (a -> a -> a) -> Bundle v a -> a
forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
Bundle.foldl1' a -> a -> a
forall a. Ord a => a -> a -> a
max (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Yield the maximum element of the vector according to the given
-- comparison function. The vector may not be empty.
maximumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
{-# INLINE maximumBy #-}
maximumBy :: (a -> a -> Ordering) -> v a -> a
maximumBy cmpr :: a -> a -> Ordering
cmpr = (a -> a -> a) -> Bundle v a -> a
forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
Bundle.foldl1' a -> a -> a
maxBy (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream
  where
    {-# INLINE maxBy #-}
    maxBy :: a -> a -> a
maxBy x :: a
x y :: a
y = case a -> a -> Ordering
cmpr a
x a
y of
                  LT -> a
y
                  _  -> a
x

-- | /O(n)/ Yield the minimum element of the vector. The vector may not be
-- empty.
minimum :: (Vector v a, Ord a) => v a -> a
{-# INLINE minimum #-}
minimum :: v a -> a
minimum = (a -> a -> a) -> Bundle v a -> a
forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
Bundle.foldl1' a -> a -> a
forall a. Ord a => a -> a -> a
min (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Yield the minimum element of the vector according to the given
-- comparison function. The vector may not be empty.
minimumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a
{-# INLINE minimumBy #-}
minimumBy :: (a -> a -> Ordering) -> v a -> a
minimumBy cmpr :: a -> a -> Ordering
cmpr = (a -> a -> a) -> Bundle v a -> a
forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
Bundle.foldl1' a -> a -> a
minBy (Bundle v a -> a) -> (v a -> Bundle v a) -> v a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream
  where
    {-# INLINE minBy #-}
    minBy :: a -> a -> a
minBy x :: a
x y :: a
y = case a -> a -> Ordering
cmpr a
x a
y of
                  GT -> a
y
                  _  -> a
x

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

-- | /O(n)/ Yield the index of the maximum element of the vector according to
-- the given comparison function. The vector may not be empty.
maxIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
{-# INLINE maxIndexBy #-}
maxIndexBy :: (a -> a -> Ordering) -> v a -> Int
maxIndexBy cmpr :: a -> a -> Ordering
cmpr = (Int, a) -> Int
forall a b. (a, b) -> a
fst ((Int, a) -> Int) -> (v a -> (Int, a)) -> v a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Int, a) -> (Int, a) -> (Int, a)) -> Bundle v (Int, a) -> (Int, a)
forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
Bundle.foldl1' (Int, a) -> (Int, a) -> (Int, a)
imax (Bundle v (Int, a) -> (Int, a))
-> (v a -> Bundle v (Int, a)) -> v a -> (Int, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle v a -> Bundle v (Int, a)
forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
Bundle.indexed (Bundle v a -> Bundle v (Int, a))
-> (v a -> Bundle v a) -> v a -> Bundle v (Int, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream
  where
    imax :: (Int, a) -> (Int, a) -> (Int, a)
imax (i :: Int
i,x :: a
x) (j :: Int
j,y :: a
y) = Int
i Int -> (Int, a) -> (Int, a)
forall a b. a -> b -> b
`seq` Int
j Int -> (Int, a) -> (Int, a)
forall a b. a -> b -> b
`seq`
                       case a -> a -> Ordering
cmpr a
x a
y of
                         LT -> (Int
j,a
y)
                         _  -> (Int
i,a
x)

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

-- | /O(n)/ Yield the index of the minimum element of the vector according to
-- the given comparison function. The vector may not be empty.
minIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int
{-# INLINE minIndexBy #-}
minIndexBy :: (a -> a -> Ordering) -> v a -> Int
minIndexBy cmpr :: a -> a -> Ordering
cmpr = (Int, a) -> Int
forall a b. (a, b) -> a
fst ((Int, a) -> Int) -> (v a -> (Int, a)) -> v a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Int, a) -> (Int, a) -> (Int, a)) -> Bundle v (Int, a) -> (Int, a)
forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
Bundle.foldl1' (Int, a) -> (Int, a) -> (Int, a)
imin (Bundle v (Int, a) -> (Int, a))
-> (v a -> Bundle v (Int, a)) -> v a -> (Int, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle v a -> Bundle v (Int, a)
forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
Bundle.indexed (Bundle v a -> Bundle v (Int, a))
-> (v a -> Bundle v a) -> v a -> Bundle v (Int, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream
  where
    imin :: (Int, a) -> (Int, a) -> (Int, a)
imin (i :: Int
i,x :: a
x) (j :: Int
j,y :: a
y) = Int
i Int -> (Int, a) -> (Int, a)
forall a b. a -> b -> b
`seq` Int
j Int -> (Int, a) -> (Int, a)
forall a b. a -> b -> b
`seq`
                       case a -> a -> Ordering
cmpr a
x a
y of
                         GT -> (Int
j,a
y)
                         _  -> (Int
i,a
x)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- Prefix sums (scans)
-- -------------------

-- | /O(n)/ Prescan
--
-- @
-- prescanl f z = 'init' . 'scanl' f z
-- @
--
-- Example: @prescanl (+) 0 \<1,2,3,4\> = \<0,1,3,6\>@
--
prescanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
{-# INLINE prescanl #-}
prescanl :: (a -> b -> a) -> a -> v b -> v a
prescanl f :: a -> b -> a
f z :: a
z = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Bundle v a -> v a) -> (v b -> Bundle v a) -> v b -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (m :: * -> *). Monad m => Stream m b -> Stream m a)
-> (Size -> Size) -> Bundle v b -> Bundle v a
forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace ((a -> b -> a) -> a -> Stream m b -> Stream m a
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> a) -> a -> Stream m b -> Stream m a
S.prescanl a -> b -> a
f a
z) Size -> Size
forall a. a -> a
id (Bundle v b -> Bundle v a)
-> (v b -> Bundle v b) -> v b -> Bundle v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v b -> Bundle v b
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

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

-- | /O(n)/ Scan
--
-- @
-- postscanl f z = 'tail' . 'scanl' f z
-- @
--
-- Example: @postscanl (+) 0 \<1,2,3,4\> = \<1,3,6,10\>@
--
postscanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
{-# INLINE postscanl #-}
postscanl :: (a -> b -> a) -> a -> v b -> v a
postscanl f :: a -> b -> a
f z :: a
z = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Bundle v a -> v a) -> (v b -> Bundle v a) -> v b -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (m :: * -> *). Monad m => Stream m b -> Stream m a)
-> (Size -> Size) -> Bundle v b -> Bundle v a
forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace ((a -> b -> a) -> a -> Stream m b -> Stream m a
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> a) -> a -> Stream m b -> Stream m a
S.postscanl a -> b -> a
f a
z) Size -> Size
forall a. a -> a
id (Bundle v b -> Bundle v a)
-> (v b -> Bundle v b) -> v b -> Bundle v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v b -> Bundle v b
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

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

-- | /O(n)/ Haskell-style scan
--
-- > scanl f z <x1,...,xn> = <y1,...,y(n+1)>
-- >   where y1 = z
-- >         yi = f y(i-1) x(i-1)
--
-- Example: @scanl (+) 0 \<1,2,3,4\> = \<0,1,3,6,10\>@
--
scanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
{-# INLINE scanl #-}
scanl :: (a -> b -> a) -> a -> v b -> v a
scanl f :: a -> b -> a
f z :: a
z = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Bundle v a -> v a) -> (v b -> Bundle v a) -> v b -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b -> a) -> a -> Bundle v b -> Bundle v a
forall a b (v :: * -> *).
(a -> b -> a) -> a -> Bundle v b -> Bundle v a
Bundle.scanl a -> b -> a
f a
z (Bundle v b -> Bundle v a)
-> (v b -> Bundle v b) -> v b -> Bundle v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v b -> Bundle v b
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

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

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

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


-- | /O(n)/ Scan over a non-empty vector
--
-- > scanl f <x1,...,xn> = <y1,...,yn>
-- >   where y1 = x1
-- >         yi = f y(i-1) xi
--
scanl1 :: Vector v a => (a -> a -> a) -> v a -> v a
{-# INLINE scanl1 #-}
scanl1 :: (a -> a -> a) -> v a -> v a
scanl1 f :: a -> a -> a
f = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
-> (Size -> Size) -> Bundle v a -> Bundle v a
forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace ((a -> a -> a) -> Stream m a -> Stream m a
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Stream m a -> Stream m a
S.scanl1 a -> a -> a
f) Size -> Size
forall a. a -> a
id (Bundle v a -> Bundle v a)
-> (v a -> Bundle v a) -> v a -> Bundle v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

-- | /O(n)/ Scan over a non-empty vector with a strict accumulator
scanl1' :: Vector v a => (a -> a -> a) -> v a -> v a
{-# INLINE scanl1' #-}
scanl1' :: (a -> a -> a) -> v a -> v a
scanl1' f :: a -> a -> a
f = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
-> (Size -> Size) -> Bundle v a -> Bundle v a
forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace ((a -> a -> a) -> Stream m a -> Stream m a
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Stream m a -> Stream m a
S.scanl1' a -> a -> a
f) Size -> Size
forall a. a -> a
id (Bundle v a -> Bundle v a)
-> (v a -> Bundle v a) -> v a -> Bundle v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream

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

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

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

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

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

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

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

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

-- | /O(n)/ Right-to-left scan over a non-empty vector
scanr1 :: Vector v a => (a -> a -> a) -> v a -> v a
{-# INLINE scanr1 #-}
scanr1 :: (a -> a -> a) -> v a -> v a
scanr1 f :: a -> a -> a
f = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstreamR (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
-> (Size -> Size) -> Bundle v a -> Bundle v a
forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace ((a -> a -> a) -> Stream m a -> Stream m a
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Stream m a -> Stream m a
S.scanl1 ((a -> a -> a) -> a -> a -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f)) Size -> Size
forall a. a -> a
id (Bundle v a -> Bundle v a)
-> (v a -> Bundle v a) -> v a -> Bundle v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a (u :: * -> *).
Vector v a =>
v a -> Bundle u a
streamR

-- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
-- accumulator
scanr1' :: Vector v a => (a -> a -> a) -> v a -> v a
{-# INLINE scanr1' #-}
scanr1' :: (a -> a -> a) -> v a -> v a
scanr1' f :: a -> a -> a
f = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstreamR (Bundle v a -> v a) -> (v a -> Bundle v a) -> v a -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (m :: * -> *). Monad m => Stream m a -> Stream m a)
-> (Size -> Size) -> Bundle v a -> Bundle v a
forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace ((a -> a -> a) -> Stream m a -> Stream m a
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Stream m a -> Stream m a
S.scanl1' ((a -> a -> a) -> a -> a -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> a
f)) Size -> Size
forall a. a -> a
id (Bundle v a -> Bundle v a)
-> (v a -> Bundle v a) -> v a -> Bundle v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v a -> Bundle v a
forall (v :: * -> *) a (u :: * -> *).
Vector v a =>
v a -> Bundle u a
streamR

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

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

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

-- | /O(n)/ Convert the first @n@ elements of a list to a vector
--
-- @
-- fromListN n xs = 'fromList' ('take' n xs)
-- @
fromListN :: Vector v a => Int -> [a] -> v a
{-# INLINE fromListN #-}
fromListN :: Int -> [a] -> v a
fromListN n :: Int
n = Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Bundle v a -> v a) -> ([a] -> Bundle v a) -> [a] -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [a] -> Bundle v a
forall a (v :: * -> *). Int -> [a] -> Bundle v a
Bundle.fromListN Int
n

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

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

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

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

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

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

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

{-# RULES

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

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



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

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

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

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

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

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

-- Same as 'stream', but can be used to avoid having a cycle in the dependency
-- graph of functions, which forces GHC to create a loop breaker.
stream' :: Vector v a => v a -> Bundle v a
{-# INLINE stream' #-}
stream' :: v a -> Bundle v a
stream' v :: v a
v = v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
Bundle.fromVector v a
v

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

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

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

{-# RULES

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

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

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

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

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



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

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

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

{-# RULES

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

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

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

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

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

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



unstreamM :: (Monad m, Vector v a) => MBundle m u a -> m (v a)
{-# INLINE_FUSED unstreamM #-}
unstreamM :: MBundle m u a -> m (v a)
unstreamM s :: MBundle m u a
s = do
                [a]
xs <- MBundle m u a -> m [a]
forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> m [a]
MBundle.toList MBundle m u a
s
                v a -> m (v a)
forall (m :: * -> *) a. Monad m => a -> m a
return (v a -> m (v a)) -> v a -> m (v a)
forall a b. (a -> b) -> a -> b
$ Bundle v a -> v a
forall (v :: * -> *) a. Vector v a => Bundle v a -> v a
unstream (Bundle v a -> v a) -> Bundle v a -> v a
forall a b. (a -> b) -> a -> b
$ Size -> [a] -> Bundle v a
forall a (v :: * -> *). Size -> [a] -> Bundle v a
Bundle.unsafeFromList (MBundle m u a -> Size
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
MBundle.size MBundle m u a
s) [a]
xs

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

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

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

{-# RULES

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




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

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

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

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

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

-- | /O(n)/
eqBy :: (Vector v a, Vector v b) => (a -> b -> Bool) -> v a -> v b -> Bool
{-# INLINE eqBy #-}
eqBy :: (a -> b -> Bool) -> v a -> v b -> Bool
eqBy e :: a -> b -> Bool
e xs :: v a
xs ys :: v b
ys = (a -> b -> Bool) -> Bundle v a -> Bundle v b -> Bool
forall a b (v :: * -> *).
(a -> b -> Bool) -> Bundle v a -> Bundle v b -> Bool
Bundle.eqBy a -> b -> Bool
e (v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v a
xs) (v b -> Bundle v b
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v b
ys)

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

-- | /O(n)/
cmpBy :: (Vector v a, Vector v b) => (a -> b -> Ordering) -> v a -> v b -> Ordering
cmpBy :: (a -> b -> Ordering) -> v a -> v b -> Ordering
cmpBy c :: a -> b -> Ordering
c xs :: v a
xs ys :: v b
ys = (a -> b -> Ordering) -> Bundle v a -> Bundle v b -> Ordering
forall a b (v :: * -> *).
(a -> b -> Ordering) -> Bundle v a -> Bundle v b -> Ordering
Bundle.cmpBy a -> b -> Ordering
c (v a -> Bundle v a
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v a
xs) (v b -> Bundle v b
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
stream v b
ys)

-- Show
-- ----

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

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

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

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

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

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

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

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

mkType :: String -> DataType
{-# INLINE mkType #-}
mkType :: String -> DataType
mkType = String -> DataType
mkNoRepType

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

#if __GLASGOW_HASKELL__ >= 707
dataCast :: (Vector v a, Data a, Typeable v, Typeable t)
#else
dataCast :: (Vector v a, Data a, Typeable1 v, Typeable1 t)
#endif
         => (forall d. Data  d => c (t d)) -> Maybe  (c (v a))
{-# INLINE dataCast #-}
dataCast :: (forall d. Data d => c (t d)) -> Maybe (c (v a))
dataCast f :: forall d. Data d => c (t d)
f = c (t a) -> Maybe (c (v a))
forall k1 k2 (c :: k1 -> *) (t :: k2 -> k1) (t' :: k2 -> k1)
       (a :: k2).
(Typeable t, Typeable t') =>
c (t a) -> Maybe (c (t' a))
gcast1 c (t a)
forall d. Data d => c (t d)
f