{- |
Like "Data.StorableVector.Lazy"
but the maximum chunk size is encoded in a type parameter.
This way, you do not need to pass a chunk size parameter at various places.
The API becomes more like the one for lists and 'ByteString's.
-}
module Data.StorableVector.Lazy.Typed (
   Vector,
   DefaultVector,
   Size,
   ChunkSize,
   chunkSize,
   lazyChunkSize,
   DefaultChunkSize,
   Size1024,
   empty,
   singleton,
   toVectorLazy,
   fromVectorLazy,
   chunks,
   fromChunks,
   pack,
   unpack,
   unfoldr,
   unfoldrResult,
   sample,
   sampleN,
   iterate,
   repeat,
   cycle,
   replicate,
   null,
   length,
   equal,
   index,
   cons,
   append,
   extendL,
   concat,
   sliceVertical,
   snoc,
   map,
   reverse,
   foldl,
   foldl',
   foldr,
   foldMap,
   any,
   all,
   maximum,
   minimum,
   viewL,
   viewR,
   switchL,
   switchR,
   scanl,
   mapAccumL,
   mapAccumR,
   crochetL,
   take,
   takeEnd,
   drop,
   splitAt,
   dropMarginRem,
   dropMargin,
   dropWhile,
   takeWhile,
   span,
   filter,
   zipWith,
   zipWith3,
   zipWith4,
   zipWithAppend,
   zipWithLastPattern,
   zipWithLastPattern3,
   zipWithLastPattern4,
   zipWithSize,
   zipWithSize3,
   zipWithSize4,
   sieve,
   deinterleave,
   interleaveFirstPattern,
   pad,
   hGetContentsAsync,
   hGetContentsSync,
   hPut,
   readFileAsync,
   writeFile,
   appendFile,
   interact,
   ) where

import qualified Data.StorableVector.Lazy as SVL
import qualified Data.StorableVector as V
import qualified Data.List as List

import Foreign.Storable (Storable)
import System.IO (IO, FilePath, Handle)
import Test.QuickCheck (Arbitrary(arbitrary))

import Control.DeepSeq (NFData, rnf)
import Control.Monad (fmap)

import Data.Function.HT (compose2)
import Data.Tuple.HT (mapPair, mapFst, mapSnd)
import Data.Maybe.HT (toMaybe)
import Data.Monoid (Monoid, mempty, mappend, mconcat)
import Data.Semigroup (Semigroup, (<>), )
import Data.Either (Either)
import Data.Maybe (Maybe(Just))
import Data.Function (flip, ($), (.))
import Data.Tuple (fst)
import Data.Bool (Bool)
import Data.Ord (Ord, (<), (>=))
import Data.Eq (Eq, (==))
import Text.Show (Show, showsPrec, showParen, showString)
import Prelude (IOError, Int, succ)


{- |
A @Vector size a@ represents a chunky storable vector
with maximum chunk size expressed by type parameter @size@.
-}
newtype Vector size a = SV {forall size a. Vector size a -> Vector a
plain :: SVL.Vector a}


newtype ChunkSize size = ChunkSize Int

lazyChunkSize :: ChunkSize size -> SVL.ChunkSize
lazyChunkSize :: forall size. ChunkSize size -> ChunkSize
lazyChunkSize (ChunkSize Int
size) = Int -> ChunkSize
SVL.chunkSize Int
size

class Size size where
   chunkSize :: ChunkSize size

instance Size Size1024 where
   chunkSize :: ChunkSize Size1024
chunkSize = forall size. Int -> ChunkSize size
ChunkSize Int
1024

_dummySize :: Size1024
_dummySize :: Size1024
_dummySize = Size1024
Size1024

type DefaultChunkSize = Size1024
data Size1024 = Size1024

type DefaultVector = Vector DefaultChunkSize


withChunkSize ::
   (Size size) => (ChunkSize size -> Vector size a) -> Vector size a
withChunkSize :: forall size a.
Size size =>
(ChunkSize size -> Vector size a) -> Vector size a
withChunkSize ChunkSize size -> Vector size a
f = ChunkSize size -> Vector size a
f forall size. Size size => ChunkSize size
chunkSize

withLazyChunkSize ::
   (Size size) => (SVL.ChunkSize -> SVL.Vector a) -> Vector size a
withLazyChunkSize :: forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize ChunkSize -> Vector a
f = forall size a.
Size size =>
(ChunkSize size -> Vector size a) -> Vector size a
withChunkSize forall a b. (a -> b) -> a -> b
$ forall a size. Vector a -> Vector size a
lift0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. ChunkSize -> Vector a
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size. ChunkSize size -> ChunkSize
lazyChunkSize

getChunkSize :: (Size size) => Vector size a -> ChunkSize size
getChunkSize :: forall size a. Size size => Vector size a -> ChunkSize size
getChunkSize Vector size a
_ = forall size. Size size => ChunkSize size
chunkSize


lift0 :: SVL.Vector a -> Vector size a
lift0 :: forall a size. Vector a -> Vector size a
lift0 = forall size a. Vector a -> Vector size a
SV

lift1 ::
   (SVL.Vector a -> SVL.Vector b) ->
   Vector size a -> Vector size b
lift1 :: forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 Vector a -> Vector b
f (SV Vector a
a) = forall size a. Vector a -> Vector size a
SV (Vector a -> Vector b
f Vector a
a)

lift2 ::
   (SVL.Vector a -> SVL.Vector b -> SVL.Vector c) ->
   Vector size a -> Vector size b -> Vector size c
lift2 :: forall a b c size.
(Vector a -> Vector b -> Vector c)
-> Vector size a -> Vector size b -> Vector size c
lift2 Vector a -> Vector b -> Vector c
f (SV Vector a
a) (SV Vector b
b) = forall size a. Vector a -> Vector size a
SV (Vector a -> Vector b -> Vector c
f Vector a
a Vector b
b)

lift3 ::
   (SVL.Vector a -> SVL.Vector b -> SVL.Vector c -> SVL.Vector d) ->
   Vector size a -> Vector size b -> Vector size c -> Vector size d
lift3 :: forall a b c d size.
(Vector a -> Vector b -> Vector c -> Vector d)
-> Vector size a -> Vector size b -> Vector size c -> Vector size d
lift3 Vector a -> Vector b -> Vector c -> Vector d
f (SV Vector a
a) (SV Vector b
b) (SV Vector c
c) = forall size a. Vector a -> Vector size a
SV (Vector a -> Vector b -> Vector c -> Vector d
f Vector a
a Vector b
b Vector c
c)

lift4 ::
   (SVL.Vector a -> SVL.Vector b -> SVL.Vector c -> SVL.Vector d ->
    SVL.Vector e) ->
   Vector size a -> Vector size b -> Vector size c -> Vector size d ->
   Vector size e
lift4 :: forall a b c d e size.
(Vector a -> Vector b -> Vector c -> Vector d -> Vector e)
-> Vector size a
-> Vector size b
-> Vector size c
-> Vector size d
-> Vector size e
lift4 Vector a -> Vector b -> Vector c -> Vector d -> Vector e
f (SV Vector a
a) (SV Vector b
b) (SV Vector c
c) (SV Vector d
d) = forall size a. Vector a -> Vector size a
SV (Vector a -> Vector b -> Vector c -> Vector d -> Vector e
f Vector a
a Vector b
b Vector c
c Vector d
d)


instance (Size size, Storable a) => Semigroup (Vector size a) where
    <> :: Vector size a -> Vector size a -> Vector size a
(<>) = forall size a.
(Size size, Storable a) =>
Vector size a -> Vector size a -> Vector size a
append

instance (Size size, Storable a) => Monoid (Vector size a) where
    mempty :: Vector size a
mempty  = forall a size. Storable a => Vector size a
empty
    mappend :: Vector size a -> Vector size a -> Vector size a
mappend = forall size a.
(Size size, Storable a) =>
Vector size a -> Vector size a -> Vector size a
append
    mconcat :: [Vector size a] -> Vector size a
mconcat = forall size a.
(Size size, Storable a) =>
[Vector size a] -> Vector size a
concat

instance (Size size, Storable a, Eq a) => Eq (Vector size a) where
   == :: Vector size a -> Vector size a -> Bool
(==) = forall size a.
(Size size, Storable a, Eq a) =>
Vector size a -> Vector size a -> Bool
equal

instance (Size size, Storable a, Show a) => Show (Vector size a) where
   showsPrec :: Int -> Vector size a -> ShowS
showsPrec Int
p Vector size a
xs =
      Bool -> ShowS -> ShowS
showParen (Int
pforall a. Ord a => a -> a -> Bool
>=Int
10)
         (String -> ShowS
showString String
"VectorLazyTyped.fromChunks " forall b c a. (b -> c) -> (a -> b) -> a -> c
.
          forall a. Show a => Int -> a -> ShowS
showsPrec Int
10 (forall a. Vector a -> [Vector a]
SVL.chunks forall a b. (a -> b) -> a -> b
$ forall size a. Vector size a -> Vector a
plain Vector size a
xs))

{- |
This generates chunks of maximum size.
If you want to have chunks of varying size, use

> fromChunks <$> arbitrary

instead.
-}
instance (Size size, Storable a, Arbitrary a) => Arbitrary (Vector size a) where
   arbitrary :: Gen (Vector size a)
arbitrary = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall size a. (Size size, Storable a) => [a] -> Vector size a
pack forall a. Arbitrary a => Gen a
arbitrary

instance (Size size, Storable a) => NFData (Vector size a) where
   rnf :: Vector size a -> ()
rnf = forall a. NFData a => a -> ()
rnf forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain


-- * Introducing and eliminating 'Vector's

{-# INLINE empty #-}
empty :: (Storable a) => Vector size a
empty :: forall a size. Storable a => Vector size a
empty = forall a size. Vector a -> Vector size a
lift0 forall a. Storable a => Vector a
SVL.empty

{-# INLINE singleton #-}
singleton :: (Storable a) => a -> Vector size a
singleton :: forall a size. Storable a => a -> Vector size a
singleton = forall a size. Vector a -> Vector size a
lift0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => a -> Vector a
SVL.singleton

toVectorLazy :: Vector size a -> SVL.Vector a
toVectorLazy :: forall size a. Vector size a -> Vector a
toVectorLazy = forall size a. Vector size a -> Vector a
plain

{- |
This will maintain all laziness breaks,
but if chunks are too big, they will be split.
-}
fromVectorLazy :: (Size size, Storable a) => SVL.Vector a -> Vector size a
fromVectorLazy :: forall size a. (Size size, Storable a) => Vector a -> Vector size a
fromVectorLazy = forall size a.
(Size size, Storable a) =>
[Vector a] -> Vector size a
fromChunks forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Vector a -> [Vector a]
SVL.chunks

chunks :: Vector size a -> [V.Vector a]
chunks :: forall size a. Vector size a -> [Vector a]
chunks = forall a. Vector a -> [Vector a]
SVL.chunks forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

fromChunks :: (Size size, Storable a) => [V.Vector a] -> Vector size a
fromChunks :: forall size a.
(Size size, Storable a) =>
[Vector a] -> Vector size a
fromChunks [Vector a]
xs =
   forall size a.
Size size =>
(ChunkSize size -> Vector size a) -> Vector size a
withChunkSize forall a b. (a -> b) -> a -> b
$ \(ChunkSize Int
size) ->
      forall a size. Storable a => [Vector a] -> Vector size a
fromChunksUnchecked forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
List.concatMap (forall a. Storable a => Int -> Vector a -> [Vector a]
V.sliceVertical Int
size) [Vector a]
xs

fromChunksUnchecked :: (Storable a) => [V.Vector a] -> Vector size a
fromChunksUnchecked :: forall a size. Storable a => [Vector a] -> Vector size a
fromChunksUnchecked = forall a size. Vector a -> Vector size a
lift0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => [Vector a] -> Vector a
SVL.fromChunks

pack :: (Size size, Storable a) => [a] -> Vector size a
pack :: forall size a. (Size size, Storable a) => [a] -> Vector size a
pack [a]
xs = forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
size -> forall a. Storable a => ChunkSize -> [a] -> Vector a
SVL.pack ChunkSize
size [a]
xs

unpack :: (Storable a) => Vector size a -> [a]
unpack :: forall a size. Storable a => Vector size a -> [a]
unpack = forall a. Storable a => Vector a -> [a]
SVL.unpack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain


{-# INLINE unfoldr #-}
unfoldr :: (Size size, Storable b) =>
   (a -> Maybe (b,a)) ->
   a ->
   Vector size b
unfoldr :: forall size b a.
(Size size, Storable b) =>
(a -> Maybe (b, a)) -> a -> Vector size b
unfoldr a -> Maybe (b, a)
f a
a =
   forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
cs -> forall b a.
Storable b =>
ChunkSize -> (a -> Maybe (b, a)) -> a -> Vector b
SVL.unfoldr ChunkSize
cs a -> Maybe (b, a)
f a
a

{-# INLINE unfoldrResult #-}
unfoldrResult :: (Size size, Storable b) =>
   (a -> Either c (b, a)) ->
   a ->
   (Vector size b, c)
unfoldrResult :: forall size b a c.
(Size size, Storable b) =>
(a -> Either c (b, a)) -> a -> (Vector size b, c)
unfoldrResult a -> Either c (b, a)
f a
a =
   let x :: (Vector size b, c)
x =
         forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst forall a size. Vector a -> Vector size a
lift0 forall a b. (a -> b) -> a -> b
$
         forall b a c.
Storable b =>
ChunkSize -> (a -> Either c (b, a)) -> a -> (Vector b, c)
SVL.unfoldrResult (forall size. ChunkSize size -> ChunkSize
lazyChunkSize forall a b. (a -> b) -> a -> b
$ forall size a. Size size => Vector size a -> ChunkSize size
getChunkSize forall a b. (a -> b) -> a -> b
$ forall a b. (a, b) -> a
fst (Vector size b, c)
x) a -> Either c (b, a)
f a
a
   in  (Vector size b, c)
x


{-# INLINE sample #-}
sample, _sample :: (Size size, Storable a) => (Int -> a) -> Vector size a
sample :: forall size a.
(Size size, Storable a) =>
(Int -> a) -> Vector size a
sample Int -> a
f = forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
cs -> forall a. Storable a => ChunkSize -> (Int -> a) -> Vector a
SVL.sample ChunkSize
cs Int -> a
f

_sample :: forall size a.
(Size size, Storable a) =>
(Int -> a) -> Vector size a
_sample Int -> a
f = forall size b a.
(Size size, Storable b) =>
(a -> Maybe (b, a)) -> a -> Vector size b
unfoldr (\Int
i -> forall a. a -> Maybe a
Just (Int -> a
f Int
i, forall a. Enum a => a -> a
succ Int
i)) Int
0

{-# INLINE sampleN #-}
sampleN, _sampleN ::
   (Size size, Storable a) => Int -> (Int -> a) -> Vector size a
sampleN :: forall size a.
(Size size, Storable a) =>
Int -> (Int -> a) -> Vector size a
sampleN Int
n Int -> a
f = forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
cs -> forall a. Storable a => ChunkSize -> Int -> (Int -> a) -> Vector a
SVL.sampleN ChunkSize
cs Int
n Int -> a
f

_sampleN :: forall size a.
(Size size, Storable a) =>
Int -> (Int -> a) -> Vector size a
_sampleN Int
n Int -> a
f = forall size b a.
(Size size, Storable b) =>
(a -> Maybe (b, a)) -> a -> Vector size b
unfoldr (\Int
i -> forall a. Bool -> a -> Maybe a
toMaybe (Int
iforall a. Ord a => a -> a -> Bool
<Int
n) (Int -> a
f Int
i, forall a. Enum a => a -> a
succ Int
i)) Int
0


{-# INLINE iterate #-}
iterate :: (Size size, Storable a) => (a -> a) -> a -> Vector size a
iterate :: forall size a.
(Size size, Storable a) =>
(a -> a) -> a -> Vector size a
iterate a -> a
f a
a = forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
cs -> forall a. Storable a => ChunkSize -> (a -> a) -> a -> Vector a
SVL.iterate ChunkSize
cs a -> a
f a
a

repeat :: (Size size, Storable a) => a -> Vector size a
repeat :: forall size a. (Size size, Storable a) => a -> Vector size a
repeat a
a = forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
cs -> forall a. Storable a => ChunkSize -> a -> Vector a
SVL.repeat ChunkSize
cs a
a

cycle :: (Size size, Storable a) => Vector size a -> Vector size a
cycle :: forall size a.
(Size size, Storable a) =>
Vector size a -> Vector size a
cycle = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a. Storable a => Vector a -> Vector a
SVL.cycle

replicate :: (Size size, Storable a) => Int -> a -> Vector size a
replicate :: forall size a. (Size size, Storable a) => Int -> a -> Vector size a
replicate Int
n a
a = forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
cs -> forall a. Storable a => ChunkSize -> Int -> a -> Vector a
SVL.replicate ChunkSize
cs Int
n a
a



-- * Basic interface

{-# INLINE null #-}
null :: (Size size, Storable a) => Vector size a -> Bool
null :: forall size a. (Size size, Storable a) => Vector size a -> Bool
null = forall a. Storable a => Vector a -> Bool
SVL.null forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

length :: Vector size a -> Int
length :: forall size a. Vector size a -> Int
length = forall a. Vector a -> Int
SVL.length forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

equal :: (Size size, Storable a, Eq a) => Vector size a -> Vector size a -> Bool
equal :: forall size a.
(Size size, Storable a, Eq a) =>
Vector size a -> Vector size a -> Bool
equal = forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
compose2 forall a. (Storable a, Eq a) => Vector a -> Vector a -> Bool
SVL.equal forall size a. Vector size a -> Vector a
plain

index :: (Size size, Storable a) => Vector size a -> Int -> a
index :: forall size a. (Size size, Storable a) => Vector size a -> Int -> a
index (SV Vector a
xs) = forall a. Storable a => Vector a -> Int -> a
SVL.index Vector a
xs


{-# INLINE cons #-}
cons :: (Size size, Storable a) => a -> Vector size a -> Vector size a
cons :: forall size a.
(Size size, Storable a) =>
a -> Vector size a -> Vector size a
cons a
x = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 (forall a. Storable a => a -> Vector a -> Vector a
SVL.cons a
x)

infixr 5 `append`

{-# INLINE append #-}
append ::
   (Size size, Storable a) => Vector size a -> Vector size a -> Vector size a
append :: forall size a.
(Size size, Storable a) =>
Vector size a -> Vector size a -> Vector size a
append = forall a b c size.
(Vector a -> Vector b -> Vector c)
-> Vector size a -> Vector size b -> Vector size c
lift2 forall a. Storable a => Vector a -> Vector a -> Vector a
SVL.append


{- |
@extendL x y@
prepends the chunk @x@ and merges it with the first chunk of @y@
if the total size is at most @size@.
This way you can prepend small chunks
while asserting a reasonable average size for chunks.
The prepended chunk must be smaller than the maximum chunk size in the Vector.
This is not checked.
-}
extendL ::
   (Size size, Storable a) => V.Vector a -> Vector size a -> Vector size a
extendL :: forall size a.
(Size size, Storable a) =>
Vector a -> Vector size a -> Vector size a
extendL Vector a
x Vector size a
ys = forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
cs -> forall a.
Storable a =>
ChunkSize -> Vector a -> Vector a -> Vector a
SVL.extendL ChunkSize
cs Vector a
x (forall size a. Vector size a -> Vector a
plain Vector size a
ys)


concat :: (Size size, Storable a) => [Vector size a] -> Vector size a
concat :: forall size a.
(Size size, Storable a) =>
[Vector size a] -> Vector size a
concat = forall a size. Vector a -> Vector size a
lift0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => [Vector a] -> Vector a
SVL.concat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
List.map forall size a. Vector size a -> Vector a
plain

sliceVertical ::
   (Size size, Storable a) => Int -> Vector size a -> [Vector size a]
sliceVertical :: forall size a.
(Size size, Storable a) =>
Int -> Vector size a -> [Vector size a]
sliceVertical Int
n = forall a b. (a -> b) -> [a] -> [b]
List.map forall a size. Vector a -> Vector size a
lift0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => Int -> Vector a -> [Vector a]
SVL.sliceVertical Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{-# INLINE snoc #-}
snoc :: (Size size, Storable a) => Vector size a -> a -> Vector size a
snoc :: forall size a.
(Size size, Storable a) =>
Vector size a -> a -> Vector size a
snoc = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. (a -> b) -> a -> b
$ \a
x -> forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a. Storable a => Vector a -> a -> Vector a
SVL.snoc a
x)


-- * Transformations

{-# INLINE map #-}
map :: (Size size, Storable x, Storable y) =>
      (x -> y)
   -> Vector size x
   -> Vector size y
map :: forall size x y.
(Size size, Storable x, Storable y) =>
(x -> y) -> Vector size x -> Vector size y
map x -> y
f = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 (forall x y.
(Storable x, Storable y) =>
(x -> y) -> Vector x -> Vector y
SVL.map x -> y
f)


reverse :: (Size size, Storable a) => Vector size a -> Vector size a
reverse :: forall size a.
(Size size, Storable a) =>
Vector size a -> Vector size a
reverse = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a. Storable a => Vector a -> Vector a
SVL.reverse


-- * Reducing 'Vector's

{-# INLINE foldl #-}
foldl :: (Size size, Storable b) => (a -> b -> a) -> a -> Vector size b -> a
foldl :: forall size b a.
(Size size, Storable b) =>
(a -> b -> a) -> a -> Vector size b -> a
foldl a -> b -> a
f a
x0 = forall b a. Storable b => (a -> b -> a) -> a -> Vector b -> a
SVL.foldl a -> b -> a
f a
x0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{-# INLINE foldl' #-}
foldl' :: (Size size, Storable b) => (a -> b -> a) -> a -> Vector size b -> a
foldl' :: forall size b a.
(Size size, Storable b) =>
(a -> b -> a) -> a -> Vector size b -> a
foldl' a -> b -> a
f a
x0 = forall b a. Storable b => (a -> b -> a) -> a -> Vector b -> a
SVL.foldl' a -> b -> a
f a
x0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{-# INLINE foldr #-}
foldr :: (Size size, Storable b) => (b -> a -> a) -> a -> Vector size b -> a
foldr :: forall size b a.
(Size size, Storable b) =>
(b -> a -> a) -> a -> Vector size b -> a
foldr b -> a -> a
f a
x0 = forall b a. Storable b => (b -> a -> a) -> a -> Vector b -> a
SVL.foldr b -> a -> a
f a
x0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain


{-# INLINE foldMap #-}
foldMap ::
   (Size size, Storable a, Monoid m) => (a -> m) -> Vector size a -> m
foldMap :: forall size a m.
(Size size, Storable a, Monoid m) =>
(a -> m) -> Vector size a -> m
foldMap a -> m
f = forall a m. (Storable a, Monoid m) => (a -> m) -> Vector a -> m
SVL.foldMap a -> m
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{-# INLINE any #-}
any :: (Size size, Storable a) => (a -> Bool) -> Vector size a -> Bool
any :: forall size a.
(Size size, Storable a) =>
(a -> Bool) -> Vector size a -> Bool
any a -> Bool
p = forall a. Storable a => (a -> Bool) -> Vector a -> Bool
SVL.any a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{-# INLINE all #-}
all :: (Size size, Storable a) => (a -> Bool) -> Vector size a -> Bool
all :: forall size a.
(Size size, Storable a) =>
(a -> Bool) -> Vector size a -> Bool
all a -> Bool
p = forall a. Storable a => (a -> Bool) -> Vector a -> Bool
SVL.all a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

maximum :: (Size size, Storable a, Ord a) => Vector size a -> a
maximum :: forall size a. (Size size, Storable a, Ord a) => Vector size a -> a
maximum = forall a. (Storable a, Ord a) => Vector a -> a
SVL.maximum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

minimum :: (Size size, Storable a, Ord a) => Vector size a -> a
minimum :: forall size a. (Size size, Storable a, Ord a) => Vector size a -> a
minimum = forall a. (Storable a, Ord a) => Vector a -> a
SVL.minimum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain


-- * inspecting a vector

{-# INLINE viewL #-}
viewL :: (Size size, Storable a) => Vector size a -> Maybe (a, Vector size a)
viewL :: forall size a.
(Size size, Storable a) =>
Vector size a -> Maybe (a, Vector size a)
viewL = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd forall a size. Vector a -> Vector size a
lift0) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => Vector a -> Maybe (a, Vector a)
SVL.viewL forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{-# INLINE viewR #-}
viewR :: (Size size, Storable a) => Vector size a -> Maybe (Vector size a, a)
viewR :: forall size a.
(Size size, Storable a) =>
Vector size a -> Maybe (Vector size a, a)
viewR = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst forall a size. Vector a -> Vector size a
lift0) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => Vector a -> Maybe (Vector a, a)
SVL.viewR forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{-# INLINE switchL #-}
switchL ::
   (Size size, Storable a) =>
   b -> (a -> Vector size a -> b) -> Vector size a -> b
switchL :: forall size a b.
(Size size, Storable a) =>
b -> (a -> Vector size a -> b) -> Vector size a -> b
switchL b
n a -> Vector size a -> b
j = forall a b.
Storable a =>
b -> (a -> Vector a -> b) -> Vector a -> b
SVL.switchL b
n (\a
a -> a -> Vector size a -> b
j a
a forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a size. Vector a -> Vector size a
lift0) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{-# INLINE switchR #-}
switchR ::
   (Size size, Storable a) =>
   b -> (Vector size a -> a -> b) -> Vector size a -> b
switchR :: forall size a b.
(Size size, Storable a) =>
b -> (Vector size a -> a -> b) -> Vector size a -> b
switchR b
n Vector size a -> a -> b
j = forall a b.
Storable a =>
b -> (Vector a -> a -> b) -> Vector a -> b
SVL.switchR b
n (Vector size a -> a -> b
j forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a size. Vector a -> Vector size a
lift0) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain


{-# INLINE scanl #-}
scanl :: (Size size, Storable a, Storable b) =>
   (a -> b -> a) -> a -> Vector size b -> Vector size a
scanl :: forall size a b.
(Size size, Storable a, Storable b) =>
(a -> b -> a) -> a -> Vector size b -> Vector size a
scanl a -> b -> a
f a
start = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a b. (a -> b) -> a -> b
$ forall a b.
(Storable a, Storable b) =>
(a -> b -> a) -> a -> Vector b -> Vector a
SVL.scanl a -> b -> a
f a
start

{-# INLINE mapAccumL #-}
mapAccumL :: (Size size, Storable a, Storable b) =>
   (acc -> a -> (acc, b)) -> acc -> Vector size a -> (acc, Vector size b)
mapAccumL :: forall size a b acc.
(Size size, Storable a, Storable b) =>
(acc -> a -> (acc, b))
-> acc -> Vector size a -> (acc, Vector size b)
mapAccumL acc -> a -> (acc, b)
f acc
start = forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd forall a size. Vector a -> Vector size a
lift0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b acc.
(Storable a, Storable b) =>
(acc -> a -> (acc, b)) -> acc -> Vector a -> (acc, Vector b)
SVL.mapAccumL acc -> a -> (acc, b)
f acc
start forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{-# INLINE mapAccumR #-}
mapAccumR :: (Size size, Storable a, Storable b) =>
   (acc -> a -> (acc, b)) -> acc -> Vector size a -> (acc, Vector size b)
mapAccumR :: forall size a b acc.
(Size size, Storable a, Storable b) =>
(acc -> a -> (acc, b))
-> acc -> Vector size a -> (acc, Vector size b)
mapAccumR acc -> a -> (acc, b)
f acc
start = forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd forall a size. Vector a -> Vector size a
lift0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b acc.
(Storable a, Storable b) =>
(acc -> a -> (acc, b)) -> acc -> Vector a -> (acc, Vector b)
SVL.mapAccumR acc -> a -> (acc, b)
f acc
start forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{-# INLINE crochetL #-}
crochetL ::
   (Size size, Storable x, Storable y) =>
      (x -> acc -> Maybe (y, acc))
   -> acc
   -> Vector size x
   -> Vector size y
crochetL :: forall size x y acc.
(Size size, Storable x, Storable y) =>
(x -> acc -> Maybe (y, acc))
-> acc -> Vector size x -> Vector size y
crochetL x -> acc -> Maybe (y, acc)
f acc
acc0 = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a b. (a -> b) -> a -> b
$ forall x y acc.
(Storable x, Storable y) =>
(x -> acc -> Maybe (y, acc)) -> acc -> Vector x -> Vector y
SVL.crochetL x -> acc -> Maybe (y, acc)
f acc
acc0



-- * sub-vectors

{-# INLINE take #-}
take :: (Size size, Storable a) => Int -> Vector size a -> Vector size a
take :: forall size a.
(Size size, Storable a) =>
Int -> Vector size a -> Vector size a
take Int
n = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Int -> Vector a -> Vector a
SVL.take Int
n

{-# INLINE takeEnd #-}
takeEnd :: (Size size, Storable a) => Int -> Vector size a -> Vector size a
takeEnd :: forall size a.
(Size size, Storable a) =>
Int -> Vector size a -> Vector size a
takeEnd Int
n = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Int -> Vector a -> Vector a
SVL.takeEnd Int
n

{-# INLINE drop #-}
drop :: (Size size, Storable a) => Int -> Vector size a -> Vector size a
drop :: forall size a.
(Size size, Storable a) =>
Int -> Vector size a -> Vector size a
drop Int
n = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Int -> Vector a -> Vector a
SVL.drop Int
n

{-# INLINE splitAt #-}
splitAt ::
   (Size size, Storable a) =>
   Int -> Vector size a -> (Vector size a, Vector size a)
splitAt :: forall size a.
(Size size, Storable a) =>
Int -> Vector size a -> (Vector size a, Vector size a)
splitAt Int
n =
   forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (forall a size. Vector a -> Vector size a
lift0, forall a size. Vector a -> Vector size a
lift0) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => Int -> Vector a -> (Vector a, Vector a)
SVL.splitAt Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain



{-# INLINE dropMarginRem #-}
dropMarginRem ::
   (Size size, Storable a) =>
   Int -> Int -> Vector size a -> (Int, Vector size a)
dropMarginRem :: forall size a.
(Size size, Storable a) =>
Int -> Int -> Vector size a -> (Int, Vector size a)
dropMarginRem Int
n Int
m = forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd forall a size. Vector a -> Vector size a
lift0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => Int -> Int -> Vector a -> (Int, Vector a)
SVL.dropMarginRem Int
n Int
m forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{-# INLINE dropMargin #-}
dropMargin ::
   (Size size, Storable a) => Int -> Int -> Vector size a -> Vector size a
dropMargin :: forall size a.
(Size size, Storable a) =>
Int -> Int -> Vector size a -> Vector size a
dropMargin Int
n Int
m = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Int -> Int -> Vector a -> Vector a
SVL.dropMargin Int
n Int
m



{-# INLINE dropWhile #-}
dropWhile ::
   (Size size, Storable a) => (a -> Bool) -> Vector size a -> Vector size a
dropWhile :: forall size a.
(Size size, Storable a) =>
(a -> Bool) -> Vector size a -> Vector size a
dropWhile a -> Bool
p = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a b. (a -> b) -> a -> b
$ forall a. Storable a => (a -> Bool) -> Vector a -> Vector a
SVL.dropWhile a -> Bool
p

{-# INLINE takeWhile #-}
takeWhile ::
   (Size size, Storable a) => (a -> Bool) -> Vector size a -> Vector size a
takeWhile :: forall size a.
(Size size, Storable a) =>
(a -> Bool) -> Vector size a -> Vector size a
takeWhile a -> Bool
p = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a b. (a -> b) -> a -> b
$ forall a. Storable a => (a -> Bool) -> Vector a -> Vector a
SVL.takeWhile a -> Bool
p


{-# INLINE span #-}
span ::
   (Size size, Storable a) =>
   (a -> Bool) -> Vector size a -> (Vector size a, Vector size a)
span :: forall size a.
(Size size, Storable a) =>
(a -> Bool) -> Vector size a -> (Vector size a, Vector size a)
span a -> Bool
p = forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (forall a size. Vector a -> Vector size a
lift0, forall a size. Vector a -> Vector size a
lift0) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a.
Storable a =>
(a -> Bool) -> Vector a -> (Vector a, Vector a)
SVL.span a -> Bool
p forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain



-- * other functions


{-# INLINE filter #-}
filter ::
   (Size size, Storable a) => (a -> Bool) -> Vector size a -> Vector size a
filter :: forall size a.
(Size size, Storable a) =>
(a -> Bool) -> Vector size a -> Vector size a
filter a -> Bool
p = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a b. (a -> b) -> a -> b
$ forall a. Storable a => (a -> Bool) -> Vector a -> Vector a
SVL.filter a -> Bool
p


{- |
Generates laziness breaks
wherever one of the input signals has a chunk boundary.
-}
{-# INLINE zipWith #-}
zipWith :: (Size size, Storable a, Storable b, Storable c) =>
      (a -> b -> c)
   -> Vector size a
   -> Vector size b
   -> Vector size c
zipWith :: forall size a b c.
(Size size, Storable a, Storable b, Storable c) =>
(a -> b -> c) -> Vector size a -> Vector size b -> Vector size c
zipWith a -> b -> c
f = forall a b c size.
(Vector a -> Vector b -> Vector c)
-> Vector size a -> Vector size b -> Vector size c
lift2 forall a b. (a -> b) -> a -> b
$ forall a b c.
(Storable a, Storable b, Storable c) =>
(a -> b -> c) -> Vector a -> Vector b -> Vector c
SVL.zipWith a -> b -> c
f

{-# INLINE zipWith3 #-}
zipWith3 :: (Size size, Storable a, Storable b, Storable c, Storable d) =>
      (a -> b -> c -> d)
   -> Vector size a
   -> Vector size b
   -> Vector size c
   -> Vector size d
zipWith3 :: forall size a b c d.
(Size size, Storable a, Storable b, Storable c, Storable d) =>
(a -> b -> c -> d)
-> Vector size a -> Vector size b -> Vector size c -> Vector size d
zipWith3 a -> b -> c -> d
f = forall a b c d size.
(Vector a -> Vector b -> Vector c -> Vector d)
-> Vector size a -> Vector size b -> Vector size c -> Vector size d
lift3 forall a b. (a -> b) -> a -> b
$ forall a b c d.
(Storable a, Storable b, Storable c, Storable d) =>
(a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
SVL.zipWith3 a -> b -> c -> d
f

{-# INLINE zipWith4 #-}
zipWith4 ::
   (Size size, Storable a, Storable b, Storable c, Storable d, Storable e) =>
      (a -> b -> c -> d -> e)
   -> Vector size a
   -> Vector size b
   -> Vector size c
   -> Vector size d
   -> Vector size e
zipWith4 :: forall size a b c d e.
(Size size, Storable a, Storable b, Storable c, Storable d,
 Storable e) =>
(a -> b -> c -> d -> e)
-> Vector size a
-> Vector size b
-> Vector size c
-> Vector size d
-> Vector size e
zipWith4 a -> b -> c -> d -> e
f = forall a b c d e size.
(Vector a -> Vector b -> Vector c -> Vector d -> Vector e)
-> Vector size a
-> Vector size b
-> Vector size c
-> Vector size d
-> Vector size e
lift4 forall a b. (a -> b) -> a -> b
$ forall a b c d e.
(Storable a, Storable b, Storable c, Storable d, Storable e) =>
(a -> b -> c -> d -> e)
-> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
SVL.zipWith4 a -> b -> c -> d -> e
f


{-# INLINE zipWithAppend #-}
zipWithAppend :: (Size size, Storable a) =>
      (a -> a -> a)
   -> Vector size a
   -> Vector size a
   -> Vector size a
zipWithAppend :: forall size a.
(Size size, Storable a) =>
(a -> a -> a) -> Vector size a -> Vector size a -> Vector size a
zipWithAppend a -> a -> a
f = forall a b c size.
(Vector a -> Vector b -> Vector c)
-> Vector size a -> Vector size b -> Vector size c
lift2 forall a b. (a -> b) -> a -> b
$ forall a.
Storable a =>
(a -> a -> a) -> Vector a -> Vector a -> Vector a
SVL.zipWithAppend a -> a -> a
f



{- |
Preserves chunk pattern of the last argument.
-}
{-# INLINE zipWithLastPattern #-}
zipWithLastPattern :: (Size size, Storable a, Storable b, Storable c) =>
      (a -> b -> c)
   -> Vector size a
   -> Vector size b
   -> Vector size c
zipWithLastPattern :: forall size a b c.
(Size size, Storable a, Storable b, Storable c) =>
(a -> b -> c) -> Vector size a -> Vector size b -> Vector size c
zipWithLastPattern a -> b -> c
f = forall a b c size.
(Vector a -> Vector b -> Vector c)
-> Vector size a -> Vector size b -> Vector size c
lift2 forall a b. (a -> b) -> a -> b
$ forall a b c.
(Storable a, Storable b, Storable c) =>
(a -> b -> c) -> Vector a -> Vector b -> Vector c
SVL.zipWithLastPattern a -> b -> c
f

{- |
Preserves chunk pattern of the last argument.
-}
{-# INLINE zipWithLastPattern3 #-}
zipWithLastPattern3 ::
   (Size size, Storable a, Storable b, Storable c, Storable d) =>
   (a -> b -> c -> d) ->
   (Vector size a -> Vector size b -> Vector size c -> Vector size d)
zipWithLastPattern3 :: forall size a b c d.
(Size size, Storable a, Storable b, Storable c, Storable d) =>
(a -> b -> c -> d)
-> Vector size a -> Vector size b -> Vector size c -> Vector size d
zipWithLastPattern3 a -> b -> c -> d
f = forall a b c d size.
(Vector a -> Vector b -> Vector c -> Vector d)
-> Vector size a -> Vector size b -> Vector size c -> Vector size d
lift3 forall a b. (a -> b) -> a -> b
$ forall a b c d.
(Storable a, Storable b, Storable c, Storable d) =>
(a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
SVL.zipWithLastPattern3 a -> b -> c -> d
f

{- |
Preserves chunk pattern of the last argument.
-}
{-# INLINE zipWithLastPattern4 #-}
zipWithLastPattern4 ::
   (Size size, Storable a, Storable b, Storable c, Storable d, Storable e) =>
   (a -> b -> c -> d -> e) ->
   (Vector size a -> Vector size b -> Vector size c -> Vector size d -> Vector size e)
zipWithLastPattern4 :: forall size a b c d e.
(Size size, Storable a, Storable b, Storable c, Storable d,
 Storable e) =>
(a -> b -> c -> d -> e)
-> Vector size a
-> Vector size b
-> Vector size c
-> Vector size d
-> Vector size e
zipWithLastPattern4 a -> b -> c -> d -> e
f = forall a b c d e size.
(Vector a -> Vector b -> Vector c -> Vector d -> Vector e)
-> Vector size a
-> Vector size b
-> Vector size c
-> Vector size d
-> Vector size e
lift4 forall a b. (a -> b) -> a -> b
$ forall a b c d e.
(Storable a, Storable b, Storable c, Storable d, Storable e) =>
(a -> b -> c -> d -> e)
-> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
SVL.zipWithLastPattern4 a -> b -> c -> d -> e
f


{-# INLINE zipWithSize #-}
zipWithSize :: (Size size, Storable a, Storable b, Storable c) =>
      (a -> b -> c)
   -> Vector size a
   -> Vector size b
   -> Vector size c
zipWithSize :: forall size a b c.
(Size size, Storable a, Storable b, Storable c) =>
(a -> b -> c) -> Vector size a -> Vector size b -> Vector size c
zipWithSize a -> b -> c
f Vector size a
a Vector size b
b =
   forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
cs -> forall a b c.
(Storable a, Storable b, Storable c) =>
ChunkSize -> (a -> b -> c) -> Vector a -> Vector b -> Vector c
SVL.zipWithSize ChunkSize
cs a -> b -> c
f (forall size a. Vector size a -> Vector a
plain Vector size a
a) (forall size a. Vector size a -> Vector a
plain Vector size b
b)

{-# INLINE zipWithSize3 #-}
zipWithSize3 ::
   (Size size, Storable a, Storable b, Storable c, Storable d) =>
   (a -> b -> c -> d) ->
   (Vector size a -> Vector size b -> Vector size c -> Vector size d)
zipWithSize3 :: forall size a b c d.
(Size size, Storable a, Storable b, Storable c, Storable d) =>
(a -> b -> c -> d)
-> Vector size a -> Vector size b -> Vector size c -> Vector size d
zipWithSize3 a -> b -> c -> d
f Vector size a
a Vector size b
b Vector size c
c =
   forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
cs ->
      forall a b c d.
(Storable a, Storable b, Storable c, Storable d) =>
ChunkSize
-> (a -> b -> c -> d)
-> Vector a
-> Vector b
-> Vector c
-> Vector d
SVL.zipWithSize3 ChunkSize
cs a -> b -> c -> d
f (forall size a. Vector size a -> Vector a
plain Vector size a
a) (forall size a. Vector size a -> Vector a
plain Vector size b
b) (forall size a. Vector size a -> Vector a
plain Vector size c
c)

{-# INLINE zipWithSize4 #-}
zipWithSize4 ::
   (Size size, Storable a, Storable b, Storable c, Storable d, Storable e) =>
   (a -> b -> c -> d -> e) ->
   (Vector size a -> Vector size b -> Vector size c -> Vector size d -> Vector size e)
zipWithSize4 :: forall size a b c d e.
(Size size, Storable a, Storable b, Storable c, Storable d,
 Storable e) =>
(a -> b -> c -> d -> e)
-> Vector size a
-> Vector size b
-> Vector size c
-> Vector size d
-> Vector size e
zipWithSize4 a -> b -> c -> d -> e
f Vector size a
a Vector size b
b Vector size c
c Vector size d
d =
   forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
cs ->
      forall a b c d e.
(Storable a, Storable b, Storable c, Storable d, Storable e) =>
ChunkSize
-> (a -> b -> c -> d -> e)
-> Vector a
-> Vector b
-> Vector c
-> Vector d
-> Vector e
SVL.zipWithSize4 ChunkSize
cs a -> b -> c -> d -> e
f (forall size a. Vector size a -> Vector a
plain Vector size a
a) (forall size a. Vector size a -> Vector a
plain Vector size b
b) (forall size a. Vector size a -> Vector a
plain Vector size c
c) (forall size a. Vector size a -> Vector a
plain Vector size d
d)


-- * interleaved vectors

{-# INLINE sieve #-}
sieve :: (Size size, Storable a) => Int -> Vector size a -> Vector size a
sieve :: forall size a.
(Size size, Storable a) =>
Int -> Vector size a -> Vector size a
sieve Int
n = forall a b size.
(Vector a -> Vector b) -> Vector size a -> Vector size b
lift1 forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Int -> Vector a -> Vector a
SVL.sieve Int
n

{-# INLINE deinterleave #-}
deinterleave ::
   (Size size, Storable a) => Int -> Vector size a -> [Vector size a]
deinterleave :: forall size a.
(Size size, Storable a) =>
Int -> Vector size a -> [Vector size a]
deinterleave Int
n =
   forall a b. (a -> b) -> [a] -> [b]
List.map forall a size. Vector a -> Vector size a
lift0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => Int -> Vector a -> [Vector a]
SVL.deinterleave Int
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

{- |
Interleave lazy vectors
while maintaining the chunk pattern of the first vector.
All input vectors must have the same length.
-}
{-# INLINE interleaveFirstPattern #-}
interleaveFirstPattern ::
   (Size size, Storable a) => [Vector size a] -> Vector size a
interleaveFirstPattern :: forall size a.
(Size size, Storable a) =>
[Vector size a] -> Vector size a
interleaveFirstPattern = forall a size. Vector a -> Vector size a
lift0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Storable a => [Vector a] -> Vector a
SVL.interleaveFirstPattern forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
List.map forall size a. Vector size a -> Vector a
plain



{- |
Ensure a minimal length of the list by appending pad values.
-}
{- disabled INLINE pad -}
pad ::
   (Size size, Storable a) =>
   a -> Int -> Vector size a -> Vector size a
pad :: forall size a.
(Size size, Storable a) =>
a -> Int -> Vector size a -> Vector size a
pad a
y Int
n Vector size a
xs = forall size a.
Size size =>
(ChunkSize -> Vector a) -> Vector size a
withLazyChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize
cs -> forall a.
Storable a =>
ChunkSize -> a -> Int -> Vector a -> Vector a
SVL.pad ChunkSize
cs a
y Int
n forall a b. (a -> b) -> a -> b
$ forall size a. Vector size a -> Vector a
plain Vector size a
xs





-- * IO

withIOErrorChunkSize ::
   (Size size) =>
   (ChunkSize size -> IO (IOError, Vector size a)) ->
   IO (IOError, Vector size a)
withIOErrorChunkSize :: forall size a.
Size size =>
(ChunkSize size -> IO (IOError, Vector size a))
-> IO (IOError, Vector size a)
withIOErrorChunkSize ChunkSize size -> IO (IOError, Vector size a)
act = ChunkSize size -> IO (IOError, Vector size a)
act forall size. Size size => ChunkSize size
chunkSize

hGetContentsAsync :: (Size size, Storable a) =>
   Handle -> IO (IOError, Vector size a)
hGetContentsAsync :: forall size a.
(Size size, Storable a) =>
Handle -> IO (IOError, Vector size a)
hGetContentsAsync Handle
h =
   forall size a.
Size size =>
(ChunkSize size -> IO (IOError, Vector size a))
-> IO (IOError, Vector size a)
withIOErrorChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize size
cs ->
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd forall a size. Vector a -> Vector size a
lift0) forall a b. (a -> b) -> a -> b
$ forall a.
Storable a =>
ChunkSize -> Handle -> IO (IOError, Vector a)
SVL.hGetContentsAsync (forall size. ChunkSize size -> ChunkSize
lazyChunkSize ChunkSize size
cs) Handle
h


withIOChunkSize ::
   (Size size) =>
   (ChunkSize size -> IO (Vector size a)) ->
   IO (Vector size a)
withIOChunkSize :: forall size a.
Size size =>
(ChunkSize size -> IO (Vector size a)) -> IO (Vector size a)
withIOChunkSize ChunkSize size -> IO (Vector size a)
act = ChunkSize size -> IO (Vector size a)
act forall size. Size size => ChunkSize size
chunkSize

hGetContentsSync ::
   (Size size, Storable a) =>
   Handle -> IO (Vector size a)
hGetContentsSync :: forall size a.
(Size size, Storable a) =>
Handle -> IO (Vector size a)
hGetContentsSync Handle
h =
   forall size a.
Size size =>
(ChunkSize size -> IO (Vector size a)) -> IO (Vector size a)
withIOChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize size
cs ->
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a size. Vector a -> Vector size a
lift0 forall a b. (a -> b) -> a -> b
$ forall a. Storable a => ChunkSize -> Handle -> IO (Vector a)
SVL.hGetContentsSync (forall size. ChunkSize size -> ChunkSize
lazyChunkSize ChunkSize size
cs) Handle
h

hPut :: (Size size, Storable a) => Handle -> Vector size a -> IO ()
hPut :: forall size a.
(Size size, Storable a) =>
Handle -> Vector size a -> IO ()
hPut Handle
h = forall a. Storable a => Handle -> Vector a -> IO ()
SVL.hPut Handle
h forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

readFileAsync ::
   (Size size, Storable a) => FilePath -> IO (IOError, Vector size a)
readFileAsync :: forall size a.
(Size size, Storable a) =>
String -> IO (IOError, Vector size a)
readFileAsync String
path =
   forall size a.
Size size =>
(ChunkSize size -> IO (IOError, Vector size a))
-> IO (IOError, Vector size a)
withIOErrorChunkSize forall a b. (a -> b) -> a -> b
$ \ChunkSize size
cs ->
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall b c a. (b -> c) -> (a, b) -> (a, c)
mapSnd forall a size. Vector a -> Vector size a
lift0) forall a b. (a -> b) -> a -> b
$ forall a.
Storable a =>
ChunkSize -> String -> IO (IOError, Vector a)
SVL.readFileAsync (forall size. ChunkSize size -> ChunkSize
lazyChunkSize ChunkSize size
cs) String
path

writeFile :: (Size size, Storable a) => FilePath -> Vector size a -> IO ()
writeFile :: forall size a.
(Size size, Storable a) =>
String -> Vector size a -> IO ()
writeFile String
path = forall a. Storable a => String -> Vector a -> IO ()
SVL.writeFile String
path forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

appendFile :: (Size size, Storable a) => FilePath -> Vector size a -> IO ()
appendFile :: forall size a.
(Size size, Storable a) =>
String -> Vector size a -> IO ()
appendFile String
path = forall a. Storable a => String -> Vector a -> IO ()
SVL.appendFile String
path forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall size a. Vector size a -> Vector a
plain

interact ::
   (Size size, Storable a) =>
   (Vector size a -> Vector size a) -> IO ()
interact :: forall size a.
(Size size, Storable a) =>
(Vector size a -> Vector size a) -> IO ()
interact = forall size a.
(Size size, Storable a) =>
ChunkSize size -> (Vector size a -> Vector size a) -> IO ()
interactAux forall size. Size size => ChunkSize size
chunkSize

interactAux ::
   (Size size, Storable a) =>
   ChunkSize size -> (Vector size a -> Vector size a) -> IO ()
interactAux :: forall size a.
(Size size, Storable a) =>
ChunkSize size -> (Vector size a -> Vector size a) -> IO ()
interactAux ChunkSize size
cs Vector size a -> Vector size a
f = forall a.
Storable a =>
ChunkSize -> (Vector a -> Vector a) -> IO ()
SVL.interact (forall size. ChunkSize size -> ChunkSize
lazyChunkSize ChunkSize size
cs) (forall size a. Vector size a -> Vector a
plain forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector size a -> Vector size a
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a size. Vector a -> Vector size a
lift0)