{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
-- |
-- Module      : Data.Vector.Fusion.Bundle.Monadic
-- Copyright   : (c) Roman Leshchinskiy 2008-2010
--                   Alexey Kuleshevich 2020-2022
--                   Aleksey Khudyakov 2020-2022
--                   Andrew Lelechenko 2020-2022
-- License     : BSD-style
--
-- Maintainer  : Haskell Libraries Team <libraries@haskell.org>
-- Stability   : experimental
-- Portability : non-portable
--
-- Monadic bundles.
--

module Data.Vector.Fusion.Bundle.Monadic (
  Bundle(..), Chunk(..), lift,

  -- * Size hints
  size, sized,

  -- * Length
  length, null,

  -- * Construction
  empty, singleton, cons, snoc, replicate, replicateM, generate, generateM, (++),

  -- * Accessing elements
  head, last, (!!), (!?),

  -- * Substreams
  slice, init, tail, take, drop,

  -- * Mapping
  map, mapM, mapM_, trans, unbox, concatMap, flatten,

  -- * Zipping
  indexed, indexedR, zipWithM_,
  zipWithM, zipWith3M, zipWith4M, zipWith5M, zipWith6M,
  zipWith, zipWith3, zipWith4, zipWith5, zipWith6,
  zip, zip3, zip4, zip5, zip6,

  -- * Comparisons
  eqBy, cmpBy,

  -- * Filtering
  filter, filterM, mapMaybeM, takeWhile, takeWhileM, dropWhile, dropWhileM,

  -- * Searching
  elem, notElem, find, findM, findIndex, findIndexM,

  -- * Folding
  foldl, foldlM, foldl1, foldl1M, foldM, fold1M,
  foldl', foldlM', foldl1', foldl1M', foldM', fold1M',
  foldr, foldrM, foldr1, foldr1M,

  -- * Specialised folds
  and, or, concatMapM,

  -- * Unfolding
  unfoldr, unfoldrM,
  unfoldrN, unfoldrNM,
  unfoldrExactN, unfoldrExactNM,
  iterateN, iterateNM,

  -- * Scans
  prescanl, prescanlM, prescanl', prescanlM',
  postscanl, postscanlM, postscanl', postscanlM',
  scanl, scanlM, scanl', scanlM',
  scanl1, scanl1M, scanl1', scanl1M',

  -- * Enumerations
  enumFromStepN, enumFromTo, enumFromThenTo,

  -- * Conversions
  toList, fromList, fromListN, unsafeFromList,
  fromVector, reVector, fromVectors, concatVectors,
  fromStream, chunks, elements
) where

import Data.Vector.Generic.Base
import qualified Data.Vector.Generic.Mutable.Base as M
import Data.Vector.Fusion.Bundle.Size
import Data.Vector.Fusion.Util ( Box(..), delay_inline, Id(..) )
import Data.Vector.Fusion.Stream.Monadic ( Stream(..), Step(..) )
import qualified Data.Vector.Fusion.Stream.Monadic as S
import Data.Vector.Internal.Check (check, Checks(..), HasCallStack)
import Control.Monad.Primitive

import qualified Data.List as List
import Data.Char      ( ord )
import GHC.Base       ( unsafeChr )
import Control.Monad  ( liftM )
import Prelude
  ( Eq, Ord, Num, Enum, Functor, Monad, Bool(..), Ordering, Char, Int, Word, Integer, Float, Double, Maybe(..), Either(..), Integral, RealFrac
  , return, fmap, otherwise, id, const, seq, max, maxBound, fromIntegral, truncate
  , (+), (-), (<), (<=), (>), (>=), (==), (/=), (&&), (.), ($), (<$), (/) )

import Data.Int  ( Int8, Int16, Int32 )
import Data.Word ( Word8, Word16, Word32, Word64 )

#include "vector.h"
#include "MachDeps.h"

#if WORD_SIZE_IN_BITS > 32
import Data.Int  ( Int64 )
#endif

data Chunk v a = Chunk Int (forall m. (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m ())

-- | Monadic streams
data Bundle m v a = Bundle { forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems  :: Stream m a
                           , forall (m :: * -> *) (v :: * -> *) a.
Bundle m v a -> Stream m (Chunk v a)
sChunks :: Stream m (Chunk v a)
                           , forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Maybe (v a)
sVector :: Maybe (v a)
                           , forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize   :: Size
                           }

-- | Convert a pure stream to a monadic stream
lift :: Monad m => Bundle Id v a -> Bundle m v a
{-# INLINE_FUSED lift #-}
lift :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift (Bundle (Stream s -> Id (Step s a)
step s
s) (Stream s -> Id (Step s (Chunk v a))
vstep s
t) Maybe (v a)
v Size
sz)
    = Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
forall (m :: * -> *) (v :: * -> *) a.
Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
Bundle ((s -> m (Step s a)) -> s -> Stream m a
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream (Step s a -> m (Step s a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step s a -> m (Step s a)) -> (s -> Step s a) -> s -> m (Step s a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Id (Step s a) -> Step s a
forall a. Id a -> a
unId (Id (Step s a) -> Step s a)
-> (s -> Id (Step s a)) -> s -> Step s a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> Id (Step s a)
step) s
s)
             ((s -> m (Step s (Chunk v a))) -> s -> Stream m (Chunk v a)
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream (Step s (Chunk v a) -> m (Step s (Chunk v a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step s (Chunk v a) -> m (Step s (Chunk v a)))
-> (s -> Step s (Chunk v a)) -> s -> m (Step s (Chunk v a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Id (Step s (Chunk v a)) -> Step s (Chunk v a)
forall a. Id a -> a
unId (Id (Step s (Chunk v a)) -> Step s (Chunk v a))
-> (s -> Id (Step s (Chunk v a))) -> s -> Step s (Chunk v a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> Id (Step s (Chunk v a))
vstep) s
t) Maybe (v a)
v Size
sz

fromStream :: Monad m => Stream m a -> Size -> Bundle m v a
{-# INLINE fromStream #-}
fromStream :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Stream s -> m (Step s a)
step s
t) Size
sz = Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
forall (m :: * -> *) (v :: * -> *) a.
Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
Bundle ((s -> m (Step s a)) -> s -> Stream m a
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream s -> m (Step s a)
step s
t) ((s -> m (Step s (Chunk v a))) -> s -> Stream m (Chunk v a)
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream s -> m (Step s (Chunk v a))
step' s
t) Maybe (v a)
forall a. Maybe a
Nothing Size
sz
  where
    step' :: s -> m (Step s (Chunk v a))
step' s
s = do Step s a
r <- s -> m (Step s a)
step s
s
                 Step s (Chunk v a) -> m (Step s (Chunk v a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step s (Chunk v a) -> m (Step s (Chunk v a)))
-> Step s (Chunk v a) -> m (Step s (Chunk v a))
forall a b. (a -> b) -> a -> b
$ (a -> Chunk v a) -> Step s a -> Step s (Chunk v a)
forall a b. (a -> b) -> Step s a -> Step s b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> Int
-> (forall (m :: * -> *).
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m ())
-> Chunk v a
forall (v :: * -> *) a.
Int
-> (forall (m :: * -> *).
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m ())
-> Chunk v a
Chunk Int
1 (\Mutable v (PrimState m) a
v -> ST (PrimState m) () -> m ()
forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a
stToPrim (ST (PrimState m) () -> m ()) -> ST (PrimState m) () -> m ()
forall a b. (a -> b) -> a -> b
$ Mutable v (PrimState m) a -> Int -> a -> ST (PrimState m) ()
forall s. Mutable v s a -> Int -> a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> a -> ST s ()
M.basicUnsafeWrite Mutable v (PrimState m) a
v Int
0 a
x)) Step s a
r

chunks :: Bundle m v a -> Stream m (Chunk v a)
{-# INLINE chunks #-}
chunks :: forall (m :: * -> *) (v :: * -> *) a.
Bundle m v a -> Stream m (Chunk v a)
chunks = Bundle m v a -> Stream m (Chunk v a)
forall (m :: * -> *) (v :: * -> *) a.
Bundle m v a -> Stream m (Chunk v a)
sChunks

elements :: Bundle m v a -> Stream m a
{-# INLINE elements #-}
elements :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
elements = Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

-- | 'Size' hint of a 'Bundle'
size :: Bundle m v a -> Size
{-# INLINE size #-}
size :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
size = Bundle m v a -> Size
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize

-- | Attach a 'Size' hint to a 'Bundle'
sized :: Bundle m v a -> Size -> Bundle m v a
{-# INLINE_FUSED sized #-}
sized :: forall (m :: * -> *) (v :: * -> *) a.
Bundle m v a -> Size -> Bundle m v a
sized Bundle m v a
s Size
sz = Bundle m v a
s { sSize = sz }

-- Length
-- ------

-- | Length of a 'Bundle'
length :: Monad m => Bundle m v a -> m Int
{-# INLINE_FUSED length #-}
length :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> m Int
length Bundle{sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Exact Int
n}  = Int -> m Int
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
length Bundle{sChunks :: forall (m :: * -> *) (v :: * -> *) a.
Bundle m v a -> Stream m (Chunk v a)
sChunks = Stream m (Chunk v a)
s} = (Int -> Chunk v a -> Int) -> Int -> Stream m (Chunk v a) -> m Int
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> a) -> a -> Stream m b -> m a
S.foldl' (\Int
n (Chunk Int
k forall (m :: * -> *).
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m ()
_) -> Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
k) Int
0 Stream m (Chunk v a)
s

-- | Check if a 'Bundle' is empty
null :: Monad m => Bundle m v a -> m Bool
{-# INLINE_FUSED null #-}
null :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> m Bool
null Bundle{sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Exact Int
n} = Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0)
null Bundle{sChunks :: forall (m :: * -> *) (v :: * -> *) a.
Bundle m v a -> Stream m (Chunk v a)
sChunks = Stream m (Chunk v a)
s} = (Chunk v a -> Bool -> Bool)
-> Bool -> Stream m (Chunk v a) -> m Bool
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> b) -> b -> Stream m a -> m b
S.foldr (\(Chunk Int
n forall (m :: * -> *).
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m ()
_) Bool
z -> Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
&& Bool
z) Bool
True Stream m (Chunk v a)
s

-- Construction
-- ------------

-- | Empty 'Bundle'
empty :: Monad m => Bundle m v a
{-# INLINE_FUSED empty #-}
empty :: forall (m :: * -> *) (v :: * -> *) a. Monad m => Bundle m v a
empty = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream Stream m a
forall (m :: * -> *) a. Monad m => Stream m a
S.empty (Int -> Size
Exact Int
0)

-- | Singleton 'Bundle'
singleton :: Monad m => a -> Bundle m v a
{-# INLINE_FUSED singleton #-}
singleton :: forall (m :: * -> *) a (v :: * -> *). Monad m => a -> Bundle m v a
singleton a
x = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (a -> Stream m a
forall (m :: * -> *) a. Monad m => a -> Stream m a
S.singleton a
x) (Int -> Size
Exact Int
1)

-- | Replicate a value to a given length
replicate :: Monad m => Int -> a -> Bundle m v a
{-# INLINE_FUSED replicate #-}
replicate :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Int -> a -> Bundle m v a
replicate Int
n a
x = Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
forall (m :: * -> *) (v :: * -> *) a.
Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
Bundle (Int -> a -> Stream m a
forall (m :: * -> *) a. Monad m => Int -> a -> Stream m a
S.replicate Int
n a
x)
                       (Chunk v a -> Stream m (Chunk v a)
forall (m :: * -> *) a. Monad m => a -> Stream m a
S.singleton (Chunk v a -> Stream m (Chunk v a))
-> Chunk v a -> Stream m (Chunk v a)
forall a b. (a -> b) -> a -> b
$ Int
-> (forall (m :: * -> *).
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m ())
-> Chunk v a
forall (v :: * -> *) a.
Int
-> (forall (m :: * -> *).
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m ())
-> Chunk v a
Chunk Int
len (\Mutable v (PrimState m) a
v -> ST (PrimState m) () -> m ()
forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a
stToPrim (ST (PrimState m) () -> m ()) -> ST (PrimState m) () -> m ()
forall a b. (a -> b) -> a -> b
$ Mutable v (PrimState m) a -> a -> ST (PrimState m) ()
forall s. Mutable v s a -> a -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> a -> ST s ()
M.basicSet Mutable v (PrimState m) a
v a
x))
                       Maybe (v a)
forall a. Maybe a
Nothing
                       (Int -> Size
Exact Int
len)
  where
    len :: Int
len = (Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
delay_inline Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
n Int
0

-- | Yield a 'Bundle' of values obtained by performing the monadic action the
-- given number of times
replicateM :: Monad m => Int -> m a -> Bundle m v a
{-# INLINE_FUSED replicateM #-}
-- NOTE: We delay inlining max here because GHC will create a join point for
-- the call to newArray# otherwise which is not really nice.
replicateM :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Int -> m a -> Bundle m v a
replicateM Int
n m a
p = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Int -> m a -> Stream m a
forall (m :: * -> *) a. Monad m => Int -> m a -> Stream m a
S.replicateM Int
n m a
p) (Int -> Size
Exact ((Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
delay_inline Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
n Int
0))

generate :: Monad m => Int -> (Int -> a) -> Bundle m v a
{-# INLINE generate #-}
generate :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Int -> (Int -> a) -> Bundle m v a
generate Int
n Int -> a
f = Int -> (Int -> m a) -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Int -> (Int -> m a) -> Bundle m v a
generateM Int
n (a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> m a) -> (Int -> a) -> Int -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> a
f)

-- | Generate a stream from its indices
generateM :: Monad m => Int -> (Int -> m a) -> Bundle m v a
{-# INLINE_FUSED generateM #-}
generateM :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Int -> (Int -> m a) -> Bundle m v a
generateM Int
n Int -> m a
f = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Int -> (Int -> m a) -> Stream m a
forall (m :: * -> *) a.
Monad m =>
Int -> (Int -> m a) -> Stream m a
S.generateM Int
n Int -> m a
f) (Int -> Size
Exact ((Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
delay_inline Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
n Int
0))

-- | Prepend an element
cons :: Monad m => a -> Bundle m v a -> Bundle m v a
{-# INLINE cons #-}
cons :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
a -> Bundle m v a -> Bundle m v a
cons a
x Bundle m v a
s = a -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *). Monad m => a -> Bundle m v a
singleton a
x Bundle m v a -> Bundle m v a -> Bundle m v a
forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Bundle m v a -> Bundle m v a
++ Bundle m v a
s

-- | Append an element
snoc :: Monad m => Bundle m v a -> a -> Bundle m v a
{-# INLINE snoc #-}
snoc :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> a -> Bundle m v a
snoc Bundle m v a
s a
x = Bundle m v a
s Bundle m v a -> Bundle m v a -> Bundle m v a
forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Bundle m v a -> Bundle m v a
++ a -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *). Monad m => a -> Bundle m v a
singleton a
x

infixr 5 ++
-- | Concatenate two 'Bundle's
(++) :: Monad m => Bundle m v a -> Bundle m v a -> Bundle m v a
{-# INLINE_FUSED (++) #-}
Bundle Stream m a
sa Stream m (Chunk v a)
ta Maybe (v a)
_ Size
na ++ :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Bundle m v a -> Bundle m v a
++ Bundle Stream m a
sb Stream m (Chunk v a)
tb Maybe (v a)
_ Size
nb = Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
forall (m :: * -> *) (v :: * -> *) a.
Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
Bundle (Stream m a
sa Stream m a -> Stream m a -> Stream m a
forall (m :: * -> *) a.
Monad m =>
Stream m a -> Stream m a -> Stream m a
S.++ Stream m a
sb) (Stream m (Chunk v a)
ta Stream m (Chunk v a)
-> Stream m (Chunk v a) -> Stream m (Chunk v a)
forall (m :: * -> *) a.
Monad m =>
Stream m a -> Stream m a -> Stream m a
S.++ Stream m (Chunk v a)
tb) Maybe (v a)
forall a. Maybe a
Nothing (Size
na Size -> Size -> Size
forall a. Num a => a -> a -> a
+ Size
nb)

-- Accessing elements
-- ------------------

-- | First element of the 'Bundle' or error if empty
head :: Monad m => Bundle m v a -> m a
{-# INLINE_FUSED head #-}
head :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> m a
head = Stream m a -> m a
forall (m :: * -> *) a.
(HasCallStack, Monad m) =>
Stream m a -> m a
S.head (Stream m a -> m a)
-> (Bundle m v a -> Stream m a) -> Bundle m v a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

-- | Last element of the 'Bundle' or error if empty
last :: Monad m => Bundle m v a -> m a
{-# INLINE_FUSED last #-}
last :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> m a
last = Stream m a -> m a
forall (m :: * -> *) a.
(HasCallStack, Monad m) =>
Stream m a -> m a
S.last (Stream m a -> m a)
-> (Bundle m v a -> Stream m a) -> Bundle m v a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

infixl 9 !!
-- | Element at the given position
(!!) :: Monad m => Bundle m v a -> Int -> m a
{-# INLINE (!!) #-}
Bundle m v a
b !! :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Int -> m a
!! Int
i = Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems Bundle m v a
b Stream m a -> Int -> m a
forall (m :: * -> *) a.
(HasCallStack, Monad m) =>
Stream m a -> Int -> m a
S.!! Int
i

infixl 9 !?
-- | Element at the given position or 'Nothing' if out of bounds
(!?) :: Monad m => Bundle m v a -> Int -> m (Maybe a)
{-# INLINE (!?) #-}
Bundle m v a
b !? :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Int -> m (Maybe a)
!? Int
i = Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems Bundle m v a
b Stream m a -> Int -> m (Maybe a)
forall (m :: * -> *) a. Monad m => Stream m a -> Int -> m (Maybe a)
S.!? Int
i

-- Substreams
-- ----------

-- | Extract a substream of the given length starting at the given position.
slice :: Monad m => Int   -- ^ starting index
                 -> Int   -- ^ length
                 -> Bundle m v a
                 -> Bundle m v a
{-# INLINE slice #-}
slice :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Int -> Int -> Bundle m v a -> Bundle m v a
slice Int
i Int
n Bundle m v a
s = Int -> Bundle m v a -> Bundle m v a
forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Int -> Bundle m v a -> Bundle m v a
take Int
n (Int -> Bundle m v a -> Bundle m v a
forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Int -> Bundle m v a -> Bundle m v a
drop Int
i Bundle m v a
s)

-- | All but the last element
init :: Monad m => Bundle m v a -> Bundle m v a
{-# INLINE_FUSED init #-}
init :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Bundle m v a
init Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
sz} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Stream m a -> Stream m a
forall (m :: * -> *) a.
(HasCallStack, Monad m) =>
Stream m a -> Stream m a
S.init Stream m a
s) (Size
szSize -> Size -> Size
forall a. Num a => a -> a -> a
-Size
1)

-- | All but the first element
tail :: Monad m => Bundle m v a -> Bundle m v a
{-# INLINE_FUSED tail #-}
tail :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Bundle m v a
tail Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
sz} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Stream m a -> Stream m a
forall (m :: * -> *) a.
(HasCallStack, Monad m) =>
Stream m a -> Stream m a
S.tail Stream m a
s) (Size
szSize -> Size -> Size
forall a. Num a => a -> a -> a
-Size
1)

-- | The first @n@ elements
take :: Monad m => Int -> Bundle m v a -> Bundle m v a
{-# INLINE_FUSED take #-}
take :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Int -> Bundle m v a -> Bundle m v a
take Int
n Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
sz} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Int -> Stream m a -> Stream m a
forall (m :: * -> *) a. Monad m => Int -> Stream m a -> Stream m a
S.take Int
n Stream m a
s) (Int -> Size -> Size
smallerThan Int
n Size
sz)

-- | All but the first @n@ elements
drop :: Monad m => Int -> Bundle m v a -> Bundle m v a
{-# INLINE_FUSED drop #-}
drop :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Int -> Bundle m v a -> Bundle m v a
drop Int
n Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
sz} =
  Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Int -> Stream m a -> Stream m a
forall (m :: * -> *) a. Monad m => Int -> Stream m a -> Stream m a
S.drop Int
n Stream m a
s) (Size -> Size -> Size
clampedSubtract Size
sz (Int -> Size
Exact Int
n))

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

instance Monad m => Functor (Bundle m v) where
  {-# INLINE fmap #-}
  fmap :: forall a b. (a -> b) -> Bundle m v a -> Bundle m v b
fmap = (a -> b) -> Bundle m v a -> Bundle m v b
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b) -> Bundle m v a -> Bundle m v b
map
  {-# INLINE (<$) #-}
  <$ :: forall a b. a -> Bundle m v b -> Bundle m v a
(<$) = (b -> a) -> Bundle m v b -> Bundle m v a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b) -> Bundle m v a -> Bundle m v b
map ((b -> a) -> Bundle m v b -> Bundle m v a)
-> (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b -> a
forall a b. a -> b -> a
const

-- | Map a function over a 'Bundle'
map :: Monad m => (a -> b) -> Bundle m v a -> Bundle m v b
{-# INLINE map #-}
map :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b) -> Bundle m v a -> Bundle m v b
map a -> b
f = (a -> m b) -> Bundle m v a -> Bundle m v b
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> m b) -> Bundle m v a -> Bundle m v b
mapM (b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> m b) -> (a -> b) -> a -> m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f)

-- | Map a monadic function over a 'Bundle'
mapM :: Monad m => (a -> m b) -> Bundle m v a -> Bundle m v b
{-# INLINE_FUSED mapM #-}
mapM :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> m b) -> Bundle m v a -> Bundle m v b
mapM a -> m b
f Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
n} = Stream m b -> Size -> Bundle m v b
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> m b) -> Stream m a -> Stream m b
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Stream m a -> Stream m b
S.mapM a -> m b
f Stream m a
s) Size
n

-- | Execute a monadic action for each element of the 'Bundle'
mapM_ :: Monad m => (a -> m b) -> Bundle m v a -> m ()
{-# INLINE_FUSED mapM_ #-}
mapM_ :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> m b) -> Bundle m v a -> m ()
mapM_ a -> m b
m = (a -> m b) -> Stream m a -> m ()
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Stream m a -> m ()
S.mapM_ a -> m b
m (Stream m a -> m ())
-> (Bundle m v a -> Stream m a) -> Bundle m v a -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

-- | Transform a 'Bundle' to use a different monad
trans :: (Monad m, Monad m') => (forall z. m z -> m' z)
                             -> Bundle m v a -> Bundle m' v a
{-# INLINE_FUSED trans #-}
trans :: forall (m :: * -> *) (m' :: * -> *) (v :: * -> *) a.
(Monad m, Monad m') =>
(forall z. m z -> m' z) -> Bundle m v a -> Bundle m' v a
trans forall z. m z -> m' z
f Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sChunks :: forall (m :: * -> *) (v :: * -> *) a.
Bundle m v a -> Stream m (Chunk v a)
sChunks = Stream m (Chunk v a)
cs, sVector :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Maybe (v a)
sVector = Maybe (v a)
v, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
n}
  = Bundle { sElems :: Stream m' a
sElems = (forall z. m z -> m' z) -> Stream m a -> Stream m' a
forall (m :: * -> *) (m' :: * -> *) a.
(Monad m, Monad m') =>
(forall z. m z -> m' z) -> Stream m a -> Stream m' a
S.trans m z -> m' z
forall z. m z -> m' z
f Stream m a
s, sChunks :: Stream m' (Chunk v a)
sChunks = (forall z. m z -> m' z)
-> Stream m (Chunk v a) -> Stream m' (Chunk v a)
forall (m :: * -> *) (m' :: * -> *) a.
(Monad m, Monad m') =>
(forall z. m z -> m' z) -> Stream m a -> Stream m' a
S.trans m z -> m' z
forall z. m z -> m' z
f Stream m (Chunk v a)
cs, sVector :: Maybe (v a)
sVector = Maybe (v a)
v, sSize :: Size
sSize = Size
n }

unbox :: Monad m => Bundle m v (Box a) -> Bundle m v a
{-# INLINE_FUSED unbox #-}
unbox :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v (Box a) -> Bundle m v a
unbox Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m (Box a)
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
n} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Stream m (Box a) -> Stream m a
forall (m :: * -> *) a. Monad m => Stream m (Box a) -> Stream m a
S.unbox Stream m (Box a)
s) Size
n

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

-- | Pair each element in a 'Bundle' with its index
indexed :: Monad m => Bundle m v a -> Bundle m v (Int,a)
{-# INLINE_FUSED indexed #-}
indexed :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Bundle m v (Int, a)
indexed Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
n} = Stream m (Int, a) -> Size -> Bundle m v (Int, a)
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Stream m a -> Stream m (Int, a)
forall (m :: * -> *) a. Monad m => Stream m a -> Stream m (Int, a)
S.indexed Stream m a
s) Size
n

-- | Pair each element in a 'Bundle' with its index, starting from the right
-- and counting down
indexedR :: Monad m => Int -> Bundle m v a -> Bundle m v (Int,a)
{-# INLINE_FUSED indexedR #-}
indexedR :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Int -> Bundle m v a -> Bundle m v (Int, a)
indexedR Int
m Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
n} = Stream m (Int, a) -> Size -> Bundle m v (Int, a)
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Int -> Stream m a -> Stream m (Int, a)
forall (m :: * -> *) a.
Monad m =>
Int -> Stream m a -> Stream m (Int, a)
S.indexedR Int
m Stream m a
s) Size
n

-- | Zip two 'Bundle's with the given monadic function
zipWithM :: Monad m => (a -> b -> m c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
{-# INLINE_FUSED zipWithM #-}
zipWithM :: forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> m c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
zipWithM a -> b -> m c
f Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
sa, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
na}
           Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m b
sb, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
nb} = Stream m c -> Size -> Bundle m v c
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c
S.zipWithM a -> b -> m c
f Stream m a
sa Stream m b
sb) (Size -> Size -> Size
smaller Size
na Size
nb)

-- FIXME: This might expose an opportunity for inplace execution.
{-# RULES

"zipWithM xs xs [Vector.Bundle]" forall f xs.
  zipWithM f (lift xs) (lift xs) = mapM (\x -> f x x) (lift xs) #-}


zipWithM_ :: Monad m => (a -> b -> m c) -> Bundle m v a -> Bundle m v b -> m ()
{-# INLINE zipWithM_ #-}
zipWithM_ :: forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> m c) -> Bundle m v a -> Bundle m v b -> m ()
zipWithM_ a -> b -> m c
f Bundle m v a
sa Bundle m v b
sb = (a -> b -> m c) -> Stream m a -> Stream m b -> m ()
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> Stream m a -> Stream m b -> m ()
S.zipWithM_ a -> b -> m c
f (Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems Bundle m v a
sa) (Bundle m v b -> Stream m b
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems Bundle m v b
sb)

zipWith3M :: Monad m => (a -> b -> c -> m d) -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
{-# INLINE_FUSED zipWith3M #-}
zipWith3M :: forall (m :: * -> *) a b c d (v :: * -> *).
Monad m =>
(a -> b -> c -> m d)
-> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
zipWith3M a -> b -> c -> m d
f Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
sa, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
na}
            Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m b
sb, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
nb}
            Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m c
sc, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
nc}
  = Stream m d -> Size -> Bundle m v d
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> b -> c -> m d)
-> Stream m a -> Stream m b -> Stream m c -> Stream m d
forall (m :: * -> *) a b c d.
Monad m =>
(a -> b -> c -> m d)
-> Stream m a -> Stream m b -> Stream m c -> Stream m d
S.zipWith3M a -> b -> c -> m d
f Stream m a
sa Stream m b
sb Stream m c
sc) (Size -> Size -> Size
smaller Size
na (Size -> Size -> Size
smaller Size
nb Size
nc))

zipWith4M :: Monad m => (a -> b -> c -> d -> m e)
                     -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
                     -> Bundle m v e
{-# INLINE zipWith4M #-}
zipWith4M :: forall (m :: * -> *) a b c d e (v :: * -> *).
Monad m =>
(a -> b -> c -> d -> m e)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
zipWith4M a -> b -> c -> d -> m e
f Bundle m v a
sa Bundle m v b
sb Bundle m v c
sc Bundle m v d
sd
  = ((a, b) -> (c, d) -> m e)
-> Bundle m v (a, b) -> Bundle m v (c, d) -> Bundle m v e
forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> m c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
zipWithM (\(a
a,b
b) (c
c,d
d) -> a -> b -> c -> d -> m e
f a
a b
b c
c d
d) (Bundle m v a -> Bundle m v b -> Bundle m v (a, b)
forall (m :: * -> *) (v :: * -> *) a b.
Monad m =>
Bundle m v a -> Bundle m v b -> Bundle m v (a, b)
zip Bundle m v a
sa Bundle m v b
sb) (Bundle m v c -> Bundle m v d -> Bundle m v (c, d)
forall (m :: * -> *) (v :: * -> *) a b.
Monad m =>
Bundle m v a -> Bundle m v b -> Bundle m v (a, b)
zip Bundle m v c
sc Bundle m v d
sd)

zipWith5M :: Monad m => (a -> b -> c -> d -> e -> m f)
                     -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
                     -> Bundle m v e -> Bundle m v f
{-# INLINE zipWith5M #-}
zipWith5M :: forall (m :: * -> *) a b c d e f (v :: * -> *).
Monad m =>
(a -> b -> c -> d -> e -> m f)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
-> Bundle m v f
zipWith5M a -> b -> c -> d -> e -> m f
f Bundle m v a
sa Bundle m v b
sb Bundle m v c
sc Bundle m v d
sd Bundle m v e
se
  = ((a, b, c) -> (d, e) -> m f)
-> Bundle m v (a, b, c) -> Bundle m v (d, e) -> Bundle m v f
forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> m c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
zipWithM (\(a
a,b
b,c
c) (d
d,e
e) -> a -> b -> c -> d -> e -> m f
f a
a b
b c
c d
d e
e) (Bundle m v a
-> Bundle m v b -> Bundle m v c -> Bundle m v (a, b, c)
forall (m :: * -> *) (v :: * -> *) a b c.
Monad m =>
Bundle m v a
-> Bundle m v b -> Bundle m v c -> Bundle m v (a, b, c)
zip3 Bundle m v a
sa Bundle m v b
sb Bundle m v c
sc) (Bundle m v d -> Bundle m v e -> Bundle m v (d, e)
forall (m :: * -> *) (v :: * -> *) a b.
Monad m =>
Bundle m v a -> Bundle m v b -> Bundle m v (a, b)
zip Bundle m v d
sd Bundle m v e
se)

zipWith6M :: Monad m => (a -> b -> c -> d -> e -> f -> m g)
                     -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
                     -> Bundle m v e -> Bundle m v f -> Bundle m v g
{-# INLINE zipWith6M #-}
zipWith6M :: forall (m :: * -> *) a b c d e f g (v :: * -> *).
Monad m =>
(a -> b -> c -> d -> e -> f -> m g)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
-> Bundle m v f
-> Bundle m v g
zipWith6M a -> b -> c -> d -> e -> f -> m g
fn Bundle m v a
sa Bundle m v b
sb Bundle m v c
sc Bundle m v d
sd Bundle m v e
se Bundle m v f
sf
  = ((a, b, c) -> (d, e, f) -> m g)
-> Bundle m v (a, b, c) -> Bundle m v (d, e, f) -> Bundle m v g
forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> m c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
zipWithM (\(a
a,b
b,c
c) (d
d,e
e,f
f) -> a -> b -> c -> d -> e -> f -> m g
fn a
a b
b c
c d
d e
e f
f) (Bundle m v a
-> Bundle m v b -> Bundle m v c -> Bundle m v (a, b, c)
forall (m :: * -> *) (v :: * -> *) a b c.
Monad m =>
Bundle m v a
-> Bundle m v b -> Bundle m v c -> Bundle m v (a, b, c)
zip3 Bundle m v a
sa Bundle m v b
sb Bundle m v c
sc)
                                                  (Bundle m v d
-> Bundle m v e -> Bundle m v f -> Bundle m v (d, e, f)
forall (m :: * -> *) (v :: * -> *) a b c.
Monad m =>
Bundle m v a
-> Bundle m v b -> Bundle m v c -> Bundle m v (a, b, c)
zip3 Bundle m v d
sd Bundle m v e
se Bundle m v f
sf)

zipWith :: Monad m => (a -> b -> c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
{-# INLINE zipWith #-}
zipWith :: forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
zipWith a -> b -> c
f = (a -> b -> m c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> m c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
zipWithM (\a
a b
b -> c -> m c
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> c
f a
a b
b))

zipWith3 :: Monad m => (a -> b -> c -> d)
                    -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
{-# INLINE zipWith3 #-}
zipWith3 :: forall (m :: * -> *) a b c d (v :: * -> *).
Monad m =>
(a -> b -> c -> d)
-> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
zipWith3 a -> b -> c -> d
f = (a -> b -> c -> m d)
-> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
forall (m :: * -> *) a b c d (v :: * -> *).
Monad m =>
(a -> b -> c -> m d)
-> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
zipWith3M (\a
a b
b c
c -> d -> m d
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> c -> d
f a
a b
b c
c))

zipWith4 :: Monad m => (a -> b -> c -> d -> e)
                    -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
                    -> Bundle m v e
{-# INLINE zipWith4 #-}
zipWith4 :: forall (m :: * -> *) a b c d e (v :: * -> *).
Monad m =>
(a -> b -> c -> d -> e)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
zipWith4 a -> b -> c -> d -> e
f = (a -> b -> c -> d -> m e)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
forall (m :: * -> *) a b c d e (v :: * -> *).
Monad m =>
(a -> b -> c -> d -> m e)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
zipWith4M (\a
a b
b c
c d
d -> e -> m e
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> c -> d -> e
f a
a b
b c
c d
d))

zipWith5 :: Monad m => (a -> b -> c -> d -> e -> f)
                    -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
                    -> Bundle m v e -> Bundle m v f
{-# INLINE zipWith5 #-}
zipWith5 :: forall (m :: * -> *) a b c d e f (v :: * -> *).
Monad m =>
(a -> b -> c -> d -> e -> f)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
-> Bundle m v f
zipWith5 a -> b -> c -> d -> e -> f
f = (a -> b -> c -> d -> e -> m f)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
-> Bundle m v f
forall (m :: * -> *) a b c d e f (v :: * -> *).
Monad m =>
(a -> b -> c -> d -> e -> m f)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
-> Bundle m v f
zipWith5M (\a
a b
b c
c d
d e
e -> f -> m f
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> c -> d -> e -> f
f a
a b
b c
c d
d e
e))

zipWith6 :: Monad m => (a -> b -> c -> d -> e -> f -> g)
                    -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
                    -> Bundle m v e -> Bundle m v f -> Bundle m v g
{-# INLINE zipWith6 #-}
zipWith6 :: forall (m :: * -> *) a b c d e f g (v :: * -> *).
Monad m =>
(a -> b -> c -> d -> e -> f -> g)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
-> Bundle m v f
-> Bundle m v g
zipWith6 a -> b -> c -> d -> e -> f -> g
fn = (a -> b -> c -> d -> e -> f -> m g)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
-> Bundle m v f
-> Bundle m v g
forall (m :: * -> *) a b c d e f g (v :: * -> *).
Monad m =>
(a -> b -> c -> d -> e -> f -> m g)
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v d
-> Bundle m v e
-> Bundle m v f
-> Bundle m v g
zipWith6M (\a
a b
b c
c d
d e
e f
f -> g -> m g
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> c -> d -> e -> f -> g
fn a
a b
b c
c d
d e
e f
f))

zip :: Monad m => Bundle m v a -> Bundle m v b -> Bundle m v (a,b)
{-# INLINE zip #-}
zip :: forall (m :: * -> *) (v :: * -> *) a b.
Monad m =>
Bundle m v a -> Bundle m v b -> Bundle m v (a, b)
zip = (a -> b -> (a, b))
-> Bundle m v a -> Bundle m v b -> Bundle m v (a, b)
forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
zipWith (,)

zip3 :: Monad m => Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v (a,b,c)
{-# INLINE zip3 #-}
zip3 :: forall (m :: * -> *) (v :: * -> *) a b c.
Monad m =>
Bundle m v a
-> Bundle m v b -> Bundle m v c -> Bundle m v (a, b, c)
zip3 = (a -> b -> c -> (a, b, c))
-> Bundle m v a
-> Bundle m v b
-> Bundle m v c
-> Bundle m v (a, b, c)
forall (m :: * -> *) a b c d (v :: * -> *).
Monad m =>
(a -> b -> c -> d)
-> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
zipWith3 (,,)

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

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

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

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

-- | Check if two 'Bundle's are equal
eqBy :: (Monad m) => (a -> b -> Bool) -> Bundle m v a -> Bundle m v b -> m Bool
{-# INLINE_FUSED eqBy #-}
eqBy :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> Bool) -> Bundle m v a -> Bundle m v b -> m Bool
eqBy a -> b -> Bool
eq Bundle m v a
x Bundle m v b
y
  | Size -> Size -> Bool
sizesAreDifferent (Bundle m v a -> Size
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize Bundle m v a
x) (Bundle m v b -> Size
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize Bundle m v b
y) = Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
  | Bool
otherwise                             = (a -> b -> Bool) -> Stream m a -> Stream m b -> m Bool
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> Bool) -> Stream m a -> Stream m b -> m Bool
S.eqBy a -> b -> Bool
eq (Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems Bundle m v a
x) (Bundle m v b -> Stream m b
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems Bundle m v b
y)
  where
    sizesAreDifferent :: Size -> Size -> Bool
    sizesAreDifferent :: Size -> Size -> Bool
sizesAreDifferent (Exact Int
a) (Exact Int
b) = Int
a Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
b
    sizesAreDifferent (Exact Int
a) (Max Int
b)   = Int
a Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
b
    sizesAreDifferent (Max Int
a)   (Exact Int
b) = Int
a Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
b
    sizesAreDifferent Size
_         Size
_         = Bool
False

-- | Lexicographically compare two 'Bundle's
cmpBy :: (Monad m) => (a -> b -> Ordering) -> Bundle m v a -> Bundle m v b -> m Ordering
{-# INLINE_FUSED cmpBy #-}
cmpBy :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> Ordering) -> Bundle m v a -> Bundle m v b -> m Ordering
cmpBy a -> b -> Ordering
cmp Bundle m v a
x Bundle m v b
y = (a -> b -> Ordering) -> Stream m a -> Stream m b -> m Ordering
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> Ordering) -> Stream m a -> Stream m b -> m Ordering
S.cmpBy a -> b -> Ordering
cmp (Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems Bundle m v a
x) (Bundle m v b -> Stream m b
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems Bundle m v b
y)

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

-- | Drop elements which do not satisfy the predicate
filter :: Monad m => (a -> Bool) -> Bundle m v a -> Bundle m v a
{-# INLINE filter #-}
filter :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> Bool) -> Bundle m v a -> Bundle m v a
filter a -> Bool
f = (a -> m Bool) -> Bundle m v a -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle m v a -> Bundle m v a
filterM (Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> m Bool) -> (a -> Bool) -> a -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
f)

-- | Drop elements which do not satisfy the monadic predicate
filterM :: Monad m => (a -> m Bool) -> Bundle m v a -> Bundle m v a
{-# INLINE_FUSED filterM #-}
filterM :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle m v a -> Bundle m v a
filterM a -> m Bool
f Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
n} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> m Bool) -> Stream m a -> Stream m a
forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Stream m a -> Stream m a
S.filterM a -> m Bool
f Stream m a
s) (Size -> Size
toMax Size
n)

-- | Apply monadic function to each element and drop all Nothings
--
-- @since 0.12.2.0
mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Bundle m v a -> Bundle m v b
{-# INLINE_FUSED mapMaybeM #-}
mapMaybeM :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> m (Maybe b)) -> Bundle m v a -> Bundle m v b
mapMaybeM a -> m (Maybe b)
f Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
n} = Stream m b -> Size -> Bundle m v b
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> m (Maybe b)) -> Stream m a -> Stream m b
forall (m :: * -> *) a b.
Monad m =>
(a -> m (Maybe b)) -> Stream m a -> Stream m b
S.mapMaybeM a -> m (Maybe b)
f Stream m a
s) (Size -> Size
toMax Size
n)

-- | Longest prefix of elements that satisfy the predicate
takeWhile :: Monad m => (a -> Bool) -> Bundle m v a -> Bundle m v a
{-# INLINE takeWhile #-}
takeWhile :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> Bool) -> Bundle m v a -> Bundle m v a
takeWhile a -> Bool
f = (a -> m Bool) -> Bundle m v a -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle m v a -> Bundle m v a
takeWhileM (Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> m Bool) -> (a -> Bool) -> a -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
f)

-- | Longest prefix of elements that satisfy the monadic predicate
takeWhileM :: Monad m => (a -> m Bool) -> Bundle m v a -> Bundle m v a
{-# INLINE_FUSED takeWhileM #-}
takeWhileM :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle m v a -> Bundle m v a
takeWhileM a -> m Bool
f Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
n} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> m Bool) -> Stream m a -> Stream m a
forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Stream m a -> Stream m a
S.takeWhileM a -> m Bool
f Stream m a
s) (Size -> Size
toMax Size
n)

-- | Drop the longest prefix of elements that satisfy the predicate
dropWhile :: Monad m => (a -> Bool) -> Bundle m v a -> Bundle m v a
{-# INLINE dropWhile #-}
dropWhile :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> Bool) -> Bundle m v a -> Bundle m v a
dropWhile a -> Bool
f = (a -> m Bool) -> Bundle m v a -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle m v a -> Bundle m v a
dropWhileM (Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> m Bool) -> (a -> Bool) -> a -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
f)

-- | Drop the longest prefix of elements that satisfy the monadic predicate
dropWhileM :: Monad m => (a -> m Bool) -> Bundle m v a -> Bundle m v a
{-# INLINE_FUSED dropWhileM #-}
dropWhileM :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle m v a -> Bundle m v a
dropWhileM a -> m Bool
f Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
n} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> m Bool) -> Stream m a -> Stream m a
forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Stream m a -> Stream m a
S.dropWhileM a -> m Bool
f Stream m a
s) (Size -> Size
toMax Size
n)

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

infix 4 `elem`
-- | Check whether the 'Bundle' contains an element
elem :: (Monad m, Eq a) => a -> Bundle m v a -> m Bool
{-# INLINE_FUSED elem #-}
elem :: forall (m :: * -> *) a (v :: * -> *).
(Monad m, Eq a) =>
a -> Bundle m v a -> m Bool
elem a
x = a -> Stream m a -> m Bool
forall (m :: * -> *) a.
(Monad m, Eq a) =>
a -> Stream m a -> m Bool
S.elem a
x (Stream m a -> m Bool)
-> (Bundle m v a -> Stream m a) -> Bundle m v a -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

infix 4 `notElem`
-- | Inverse of `elem`
notElem :: (Monad m, Eq a) => a -> Bundle m v a -> m Bool
{-# INLINE notElem #-}
notElem :: forall (m :: * -> *) a (v :: * -> *).
(Monad m, Eq a) =>
a -> Bundle m v a -> m Bool
notElem a
x = a -> Stream m a -> m Bool
forall (m :: * -> *) a.
(Monad m, Eq a) =>
a -> Stream m a -> m Bool
S.notElem a
x (Stream m a -> m Bool)
-> (Bundle m v a -> Stream m a) -> Bundle m v a -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

-- | Yield 'Just' the first element that satisfies the predicate or 'Nothing'
-- if no such element exists.
find :: Monad m => (a -> Bool) -> Bundle m v a -> m (Maybe a)
{-# INLINE find #-}
find :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> Bool) -> Bundle m v a -> m (Maybe a)
find a -> Bool
f = (a -> m Bool) -> Bundle m v a -> m (Maybe a)
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle m v a -> m (Maybe a)
findM (Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> m Bool) -> (a -> Bool) -> a -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
f)

-- | Yield 'Just' the first element that satisfies the monadic predicate or
-- 'Nothing' if no such element exists.
findM :: Monad m => (a -> m Bool) -> Bundle m v a -> m (Maybe a)
{-# INLINE_FUSED findM #-}
findM :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle m v a -> m (Maybe a)
findM a -> m Bool
f = (a -> m Bool) -> Stream m a -> m (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Stream m a -> m (Maybe a)
S.findM a -> m Bool
f (Stream m a -> m (Maybe a))
-> (Bundle m v a -> Stream m a) -> Bundle m v a -> m (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

-- | Yield 'Just' the index of the first element that satisfies the predicate
-- or 'Nothing' if no such element exists.
findIndex :: Monad m => (a -> Bool) -> Bundle m v a -> m (Maybe Int)
{-# INLINE_FUSED findIndex #-}
findIndex :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> Bool) -> Bundle m v a -> m (Maybe Int)
findIndex a -> Bool
f = (a -> m Bool) -> Bundle m v a -> m (Maybe Int)
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle m v a -> m (Maybe Int)
findIndexM (Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> m Bool) -> (a -> Bool) -> a -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
f)

-- | Yield 'Just' the index of the first element that satisfies the monadic
-- predicate or 'Nothing' if no such element exists.
findIndexM :: Monad m => (a -> m Bool) -> Bundle m v a -> m (Maybe Int)
{-# INLINE_FUSED findIndexM #-}
findIndexM :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle m v a -> m (Maybe Int)
findIndexM a -> m Bool
f = (a -> m Bool) -> Stream m a -> m (Maybe Int)
forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Stream m a -> m (Maybe Int)
S.findIndexM a -> m Bool
f (Stream m a -> m (Maybe Int))
-> (Bundle m v a -> Stream m a) -> Bundle m v a -> m (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

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

-- | Left fold
foldl :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> m a
{-# INLINE foldl #-}
foldl :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> m a
foldl a -> b -> a
f = (a -> b -> m a) -> a -> Bundle m v b -> m a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> m a
foldlM (\a
a b
b -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> a
f a
a b
b))

-- | Left fold with a monadic operator
foldlM :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a
{-# INLINE_FUSED foldlM #-}
foldlM :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> m a
foldlM a -> b -> m a
m a
z = (a -> b -> m a) -> a -> Stream m b -> m a
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> m a) -> a -> Stream m b -> m a
S.foldlM a -> b -> m a
m a
z (Stream m b -> m a)
-> (Bundle m v b -> Stream m b) -> Bundle m v b -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v b -> Stream m b
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

-- | Same as 'foldlM'
foldM :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a
{-# INLINE foldM #-}
foldM :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> m a
foldM = (a -> b -> m a) -> a -> Bundle m v b -> m a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> m a
foldlM

-- | Left fold over a non-empty 'Bundle'
foldl1 :: Monad m => (a -> a -> a) -> Bundle m v a -> m a
{-# INLINE foldl1 #-}
foldl1 :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> a) -> Bundle m v a -> m a
foldl1 a -> a -> a
f = (a -> a -> m a) -> Bundle m v a -> m a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
foldl1M (\a
a a
b -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> a
f a
a a
b))

-- | Left fold over a non-empty 'Bundle' with a monadic operator
foldl1M :: Monad m => (a -> a -> m a) -> Bundle m v a -> m a
{-# INLINE_FUSED foldl1M #-}
foldl1M :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
foldl1M a -> a -> m a
f = (a -> a -> m a) -> Stream m a -> m a
forall (m :: * -> *) a.
(HasCallStack, Monad m) =>
(a -> a -> m a) -> Stream m a -> m a
S.foldl1M a -> a -> m a
f (Stream m a -> m a)
-> (Bundle m v a -> Stream m a) -> Bundle m v a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

-- | Same as 'foldl1M'
fold1M :: Monad m => (a -> a -> m a) -> Bundle m v a -> m a
{-# INLINE fold1M #-}
fold1M :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
fold1M = (a -> a -> m a) -> Bundle m v a -> m a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
foldl1M

-- | Left fold with a strict accumulator
foldl' :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> m a
{-# INLINE foldl' #-}
foldl' :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> m a
foldl' a -> b -> a
f = (a -> b -> m a) -> a -> Bundle m v b -> m a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> m a
foldlM' (\a
a b
b -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> a
f a
a b
b))

-- | Left fold with a strict accumulator and a monadic operator
foldlM' :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a
{-# INLINE_FUSED foldlM' #-}
foldlM' :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> m a
foldlM' a -> b -> m a
m a
z = (a -> b -> m a) -> a -> Stream m b -> m a
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> m a) -> a -> Stream m b -> m a
S.foldlM' a -> b -> m a
m a
z (Stream m b -> m a)
-> (Bundle m v b -> Stream m b) -> Bundle m v b -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v b -> Stream m b
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

-- | Same as 'foldlM''
foldM' :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a
{-# INLINE foldM' #-}
foldM' :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> m a
foldM' = (a -> b -> m a) -> a -> Bundle m v b -> m a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> m a
foldlM'

-- | Left fold over a non-empty 'Bundle' with a strict accumulator
foldl1' :: Monad m => (a -> a -> a) -> Bundle m v a -> m a
{-# INLINE foldl1' #-}
foldl1' :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> a) -> Bundle m v a -> m a
foldl1' a -> a -> a
f = (a -> a -> m a) -> Bundle m v a -> m a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
foldl1M' (\a
a a
b -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> a
f a
a a
b))

-- | Left fold over a non-empty 'Bundle' with a strict accumulator and a
-- monadic operator
foldl1M' :: Monad m => (a -> a -> m a) -> Bundle m v a -> m a
{-# INLINE_FUSED foldl1M' #-}
foldl1M' :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
foldl1M' a -> a -> m a
f = (a -> a -> m a) -> Stream m a -> m a
forall (m :: * -> *) a.
(HasCallStack, Monad m) =>
(a -> a -> m a) -> Stream m a -> m a
S.foldl1M' a -> a -> m a
f (Stream m a -> m a)
-> (Bundle m v a -> Stream m a) -> Bundle m v a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

-- | Same as 'foldl1M''
fold1M' :: Monad m => (a -> a -> m a) -> Bundle m v a -> m a
{-# INLINE fold1M' #-}
fold1M' :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
fold1M' = (a -> a -> m a) -> Bundle m v a -> m a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
foldl1M'

-- | Right fold
foldr :: Monad m => (a -> b -> b) -> b -> Bundle m v a -> m b
{-# INLINE foldr #-}
foldr :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> b) -> b -> Bundle m v a -> m b
foldr a -> b -> b
f = (a -> b -> m b) -> b -> Bundle m v a -> m b
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m b) -> b -> Bundle m v a -> m b
foldrM (\a
a b
b -> b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> b
f a
a b
b))

-- | Right fold with a monadic operator
foldrM :: Monad m => (a -> b -> m b) -> b -> Bundle m v a -> m b
{-# INLINE_FUSED foldrM #-}
foldrM :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m b) -> b -> Bundle m v a -> m b
foldrM a -> b -> m b
f b
z = (a -> b -> m b) -> b -> Stream m a -> m b
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> m b) -> b -> Stream m a -> m b
S.foldrM a -> b -> m b
f b
z (Stream m a -> m b)
-> (Bundle m v a -> Stream m a) -> Bundle m v a -> m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

-- | Right fold over a non-empty stream
foldr1 :: Monad m => (a -> a -> a) -> Bundle m v a -> m a
{-# INLINE foldr1 #-}
foldr1 :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> a) -> Bundle m v a -> m a
foldr1 a -> a -> a
f = (a -> a -> m a) -> Bundle m v a -> m a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
foldr1M (\a
a a
b -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> a
f a
a a
b))

-- | Right fold over a non-empty stream with a monadic operator
foldr1M :: Monad m => (a -> a -> m a) -> Bundle m v a -> m a
{-# INLINE_FUSED foldr1M #-}
foldr1M :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
foldr1M a -> a -> m a
f = (a -> a -> m a) -> Stream m a -> m a
forall (m :: * -> *) a.
(HasCallStack, Monad m) =>
(a -> a -> m a) -> Stream m a -> m a
S.foldr1M a -> a -> m a
f (Stream m a -> m a)
-> (Bundle m v a -> Stream m a) -> Bundle m v a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v a -> Stream m a
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

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

and :: Monad m => Bundle m v Bool -> m Bool
{-# INLINE_FUSED and #-}
and :: forall (m :: * -> *) (v :: * -> *).
Monad m =>
Bundle m v Bool -> m Bool
and = Stream m Bool -> m Bool
forall (m :: * -> *). Monad m => Stream m Bool -> m Bool
S.and (Stream m Bool -> m Bool)
-> (Bundle m v Bool -> Stream m Bool) -> Bundle m v Bool -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v Bool -> Stream m Bool
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

or :: Monad m => Bundle m v Bool -> m Bool
{-# INLINE_FUSED or #-}
or :: forall (m :: * -> *) (v :: * -> *).
Monad m =>
Bundle m v Bool -> m Bool
or = Stream m Bool -> m Bool
forall (m :: * -> *). Monad m => Stream m Bool -> m Bool
S.or (Stream m Bool -> m Bool)
-> (Bundle m v Bool -> Stream m Bool) -> Bundle m v Bool -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bundle m v Bool -> Stream m Bool
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems

concatMap :: Monad m => (a -> Bundle m v b) -> Bundle m v a -> Bundle m v b
{-# INLINE concatMap #-}
concatMap :: forall (m :: * -> *) a (v :: * -> *) b.
Monad m =>
(a -> Bundle m v b) -> Bundle m v a -> Bundle m v b
concatMap a -> Bundle m v b
f = (a -> m (Bundle m v b)) -> Bundle m v a -> Bundle m v b
forall (m :: * -> *) a (v :: * -> *) b.
Monad m =>
(a -> m (Bundle m v b)) -> Bundle m v a -> Bundle m v b
concatMapM (Bundle m v b -> m (Bundle m v b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bundle m v b -> m (Bundle m v b))
-> (a -> Bundle m v b) -> a -> m (Bundle m v b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bundle m v b
f)

concatMapM :: Monad m => (a -> m (Bundle m v b)) -> Bundle m v a -> Bundle m v b
{-# INLINE_FUSED concatMapM #-}
concatMapM :: forall (m :: * -> *) a (v :: * -> *) b.
Monad m =>
(a -> m (Bundle m v b)) -> Bundle m v a -> Bundle m v b
concatMapM a -> m (Bundle m v b)
f Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s} = Stream m b -> Size -> Bundle m v b
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> m (Stream m b)) -> Stream m a -> Stream m b
forall (m :: * -> *) a b.
Monad m =>
(a -> m (Stream m b)) -> Stream m a -> Stream m b
S.concatMapM ((Bundle m v b -> Stream m b) -> m (Bundle m v b) -> m (Stream m b)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM Bundle m v b -> Stream m b
forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems (m (Bundle m v b) -> m (Stream m b))
-> (a -> m (Bundle m v b)) -> a -> m (Stream m b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m (Bundle m v b)
f) Stream m a
s) Size
Unknown

-- | Create a 'Bundle' of values from a 'Bundle' of streamable things
flatten :: Monad m => (a -> m s) -> (s -> m (Step s b)) -> Size
                   -> Bundle m v a -> Bundle m v b
{-# INLINE_FUSED flatten #-}
flatten :: forall (m :: * -> *) a s b (v :: * -> *).
Monad m =>
(a -> m s)
-> (s -> m (Step s b)) -> Size -> Bundle m v a -> Bundle m v b
flatten a -> m s
mk s -> m (Step s b)
istep Size
sz Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s} = Stream m b -> Size -> Bundle m v b
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> m s) -> (s -> m (Step s b)) -> Stream m a -> Stream m b
forall (m :: * -> *) a s b.
Monad m =>
(a -> m s) -> (s -> m (Step s b)) -> Stream m a -> Stream m b
S.flatten a -> m s
mk s -> m (Step s b)
istep Stream m a
s) Size
sz

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

-- | Unfold
unfoldr :: Monad m => (s -> Maybe (a, s)) -> s -> Bundle m u a
{-# INLINE_FUSED unfoldr #-}
unfoldr :: forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
(s -> Maybe (a, s)) -> s -> Bundle m u a
unfoldr s -> Maybe (a, s)
f = (s -> m (Maybe (a, s))) -> s -> Bundle m u a
forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
(s -> m (Maybe (a, s))) -> s -> Bundle m u a
unfoldrM (Maybe (a, s) -> m (Maybe (a, s))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (a, s) -> m (Maybe (a, s)))
-> (s -> Maybe (a, s)) -> s -> m (Maybe (a, s))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> Maybe (a, s)
f)

-- | Unfold with a monadic function
unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Bundle m u a
{-# INLINE_FUSED unfoldrM #-}
unfoldrM :: forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
(s -> m (Maybe (a, s))) -> s -> Bundle m u a
unfoldrM s -> m (Maybe (a, s))
f s
s = Stream m a -> Size -> Bundle m u a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((s -> m (Maybe (a, s))) -> s -> Stream m a
forall (m :: * -> *) s a.
Monad m =>
(s -> m (Maybe (a, s))) -> s -> Stream m a
S.unfoldrM s -> m (Maybe (a, s))
f s
s) Size
Unknown

-- | Unfold at most @n@ elements
unfoldrN :: Monad m => Int -> (s -> Maybe (a, s)) -> s -> Bundle m u a
{-# INLINE_FUSED unfoldrN #-}
unfoldrN :: forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
Int -> (s -> Maybe (a, s)) -> s -> Bundle m u a
unfoldrN Int
n s -> Maybe (a, s)
f = Int -> (s -> m (Maybe (a, s))) -> s -> Bundle m u a
forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
Int -> (s -> m (Maybe (a, s))) -> s -> Bundle m u a
unfoldrNM Int
n (Maybe (a, s) -> m (Maybe (a, s))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (a, s) -> m (Maybe (a, s)))
-> (s -> Maybe (a, s)) -> s -> m (Maybe (a, s))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> Maybe (a, s)
f)

-- | Unfold at most @n@ elements with a monadic function.
unfoldrNM :: Monad m => Int -> (s -> m (Maybe (a, s))) -> s -> Bundle m u a
{-# INLINE_FUSED unfoldrNM #-}
unfoldrNM :: forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
Int -> (s -> m (Maybe (a, s))) -> s -> Bundle m u a
unfoldrNM Int
n s -> m (Maybe (a, s))
f s
s = Stream m a -> Size -> Bundle m u a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Int -> (s -> m (Maybe (a, s))) -> s -> Stream m a
forall (m :: * -> *) s a.
Monad m =>
Int -> (s -> m (Maybe (a, s))) -> s -> Stream m a
S.unfoldrNM Int
n s -> m (Maybe (a, s))
f s
s) Size
Unknown

-- | Unfold exactly @n@ elements
--
-- @since 0.12.2.0
unfoldrExactN :: Monad m => Int -> (s -> (a, s)) -> s -> Bundle m u a
{-# INLINE_FUSED unfoldrExactN #-}
unfoldrExactN :: forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
Int -> (s -> (a, s)) -> s -> Bundle m u a
unfoldrExactN Int
n s -> (a, s)
f = Int -> (s -> m (a, s)) -> s -> Bundle m u a
forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
Int -> (s -> m (a, s)) -> s -> Bundle m u a
unfoldrExactNM Int
n ((a, s) -> m (a, s)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ((a, s) -> m (a, s)) -> (s -> (a, s)) -> s -> m (a, s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> (a, s)
f)

-- | Unfold exactly @n@ elements with a monadic function.
--
-- @since 0.12.2.0
unfoldrExactNM :: Monad m => Int -> (s -> m (a, s)) -> s -> Bundle m u a
{-# INLINE_FUSED unfoldrExactNM #-}
unfoldrExactNM :: forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
Int -> (s -> m (a, s)) -> s -> Bundle m u a
unfoldrExactNM Int
n s -> m (a, s)
f s
s = Stream m a -> Size -> Bundle m u a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Int -> (s -> m (a, s)) -> s -> Stream m a
forall (m :: * -> *) s a.
Monad m =>
Int -> (s -> m (a, s)) -> s -> Stream m a
S.unfoldrExactNM Int
n s -> m (a, s)
f s
s) (Int -> Size
Max ((Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
delay_inline Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
n Int
0))

-- | /O(n)/ Apply monadic function \(\max(n - 1, 0)\) times to an initial value, producing
-- a monadic bundle of exact length \(\max(n, 0)\). Zeroth element will contain the initial
-- value.
iterateNM :: Monad m => Int -> (a -> m a) -> a -> Bundle m u a
{-# INLINE_FUSED iterateNM #-}
iterateNM :: forall (m :: * -> *) a (u :: * -> *).
Monad m =>
Int -> (a -> m a) -> a -> Bundle m u a
iterateNM Int
n a -> m a
f a
x0 = Stream m a -> Size -> Bundle m u a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Int -> (a -> m a) -> a -> Stream m a
forall (m :: * -> *) a.
Monad m =>
Int -> (a -> m a) -> a -> Stream m a
S.iterateNM Int
n a -> m a
f a
x0) (Int -> Size
Exact ((Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
delay_inline Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
n Int
0))

-- | /O(n)/ Apply function \(\max(n - 1, 0)\) times to an initial value, producing a
-- monadic bundle of exact length \(\max(n, 0)\). Zeroth element will contain the initial
-- value.
iterateN :: Monad m => Int -> (a -> a) -> a -> Bundle m u a
{-# INLINE_FUSED iterateN #-}
iterateN :: forall (m :: * -> *) a (u :: * -> *).
Monad m =>
Int -> (a -> a) -> a -> Bundle m u a
iterateN Int
n a -> a
f a
x0 = Int -> (a -> m a) -> a -> Bundle m u a
forall (m :: * -> *) a (u :: * -> *).
Monad m =>
Int -> (a -> m a) -> a -> Bundle m u a
iterateNM Int
n (a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> m a) -> (a -> a) -> a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a
f) a
x0

-- Scans
-- -----

-- | Prefix scan
prescanl :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE prescanl #-}
prescanl :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
prescanl a -> b -> a
f = (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
prescanlM (\a
a b
b -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> a
f a
a b
b))

-- | Prefix scan with a monadic operator
prescanlM :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE_FUSED prescanlM #-}
prescanlM :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
prescanlM a -> b -> m a
f a
z Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m b
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
sz} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> b -> m a) -> a -> Stream m b -> Stream m a
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> m a) -> a -> Stream m b -> Stream m a
S.prescanlM a -> b -> m a
f a
z Stream m b
s) Size
sz

-- | Prefix scan with strict accumulator
prescanl' :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE prescanl' #-}
prescanl' :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
prescanl' a -> b -> a
f = (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
prescanlM' (\a
a b
b -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> a
f a
a b
b))

-- | Prefix scan with strict accumulator and a monadic operator
prescanlM' :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE_FUSED prescanlM' #-}
prescanlM' :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
prescanlM' a -> b -> m a
f a
z Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m b
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
sz} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> b -> m a) -> a -> Stream m b -> Stream m a
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> m a) -> a -> Stream m b -> Stream m a
S.prescanlM' a -> b -> m a
f a
z Stream m b
s) Size
sz

-- | Suffix scan
postscanl :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE postscanl #-}
postscanl :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
postscanl a -> b -> a
f = (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
postscanlM (\a
a b
b -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> a
f a
a b
b))

-- | Suffix scan with a monadic operator
postscanlM :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE_FUSED postscanlM #-}
postscanlM :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
postscanlM a -> b -> m a
f a
z Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m b
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
sz} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> b -> m a) -> a -> Stream m b -> Stream m a
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> m a) -> a -> Stream m b -> Stream m a
S.postscanlM a -> b -> m a
f a
z Stream m b
s) Size
sz

-- | Suffix scan with strict accumulator
postscanl' :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE postscanl' #-}
postscanl' :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
postscanl' a -> b -> a
f = (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
postscanlM' (\a
a b
b -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> a
f a
a b
b))

-- | Suffix scan with strict accumulator and a monadic operator
postscanlM' :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE_FUSED postscanlM' #-}
postscanlM' :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
postscanlM' a -> b -> m a
f a
z Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m b
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
sz} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> b -> m a) -> a -> Stream m b -> Stream m a
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> m a) -> a -> Stream m b -> Stream m a
S.postscanlM' a -> b -> m a
f a
z Stream m b
s) Size
sz

-- | Haskell-style scan
scanl :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE scanl #-}
scanl :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
scanl a -> b -> a
f = (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
scanlM (\a
a b
b -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> a
f a
a b
b))

-- | Haskell-style scan with a monadic operator
scanlM :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE scanlM #-}
scanlM :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
scanlM a -> b -> m a
f a
z Bundle m v b
s = a
z a -> Bundle m v a -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
a -> Bundle m v a -> Bundle m v a
`cons` (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
postscanlM a -> b -> m a
f a
z Bundle m v b
s

-- | Haskell-style scan with strict accumulator
scanl' :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE scanl' #-}
scanl' :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
scanl' a -> b -> a
f = (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
scanlM' (\a
a b
b -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> a
f a
a b
b))

-- | Haskell-style scan with strict accumulator and a monadic operator
scanlM' :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
{-# INLINE scanlM' #-}
scanlM' :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
scanlM' a -> b -> m a
f a
z Bundle m v b
s = a
z a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` (a
z a -> Bundle m v a -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
a -> Bundle m v a -> Bundle m v a
`cons` (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a
postscanlM a -> b -> m a
f a
z Bundle m v b
s)

-- | Initial-value free scan over a 'Bundle'
scanl1 :: Monad m => (a -> a -> a) -> Bundle m v a -> Bundle m v a
{-# INLINE scanl1 #-}
scanl1 :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> a) -> Bundle m v a -> Bundle m v a
scanl1 a -> a -> a
f = (a -> a -> m a) -> Bundle m v a -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> Bundle m v a
scanl1M (\a
x a
y -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> a
f a
x a
y))

-- | Initial-value free scan over a 'Bundle' with a monadic operator
scanl1M :: Monad m => (a -> a -> m a) -> Bundle m v a -> Bundle m v a
{-# INLINE_FUSED scanl1M #-}
scanl1M :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> Bundle m v a
scanl1M a -> a -> m a
f Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
sz} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> a -> m a) -> Stream m a -> Stream m a
forall (m :: * -> *) a.
Monad m =>
(a -> a -> m a) -> Stream m a -> Stream m a
S.scanl1M a -> a -> m a
f Stream m a
s) Size
sz

-- | Initial-value free scan over a 'Bundle' with a strict accumulator
scanl1' :: Monad m => (a -> a -> a) -> Bundle m v a -> Bundle m v a
{-# INLINE scanl1' #-}
scanl1' :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> a) -> Bundle m v a -> Bundle m v a
scanl1' a -> a -> a
f = (a -> a -> m a) -> Bundle m v a -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> Bundle m v a
scanl1M' (\a
x a
y -> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> a
f a
x a
y))

-- | Initial-value free scan over a 'Bundle' with a strict accumulator
-- and a monadic operator
scanl1M' :: Monad m => (a -> a -> m a) -> Bundle m v a -> Bundle m v a
{-# INLINE_FUSED scanl1M' #-}
scanl1M' :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> Bundle m v a
scanl1M' a -> a -> m a
f Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
sz} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> a -> m a) -> Stream m a -> Stream m a
forall (m :: * -> *) a.
Monad m =>
(a -> a -> m a) -> Stream m a -> Stream m a
S.scanl1M' a -> a -> m a
f Stream m a
s) Size
sz

-- Enumerations
-- ------------

-- The Enum class is broken for this, there just doesn't seem to be a
-- way to implement this generically. We have to specialise for as many types
-- as we can but this doesn't help in polymorphic loops.

-- | Yield a 'Bundle' of the given length containing the values @x@, @x+y@,
-- @x+y+y@ etc.
enumFromStepN :: (Num a, Monad m) => a -> a -> Int -> Bundle m v a
{-# INLINE_FUSED enumFromStepN #-}
enumFromStepN :: forall a (m :: * -> *) (v :: * -> *).
(Num a, Monad m) =>
a -> a -> Int -> Bundle m v a
enumFromStepN a
x a
y Int
n = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (a -> a -> Int -> Stream m a
forall a (m :: * -> *).
(Num a, Monad m) =>
a -> a -> Int -> Stream m a
S.enumFromStepN a
x a
y Int
n) (Int -> Size
Exact ((Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
delay_inline Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
n Int
0))

-- | Enumerate values
--
-- /WARNING:/ This operation can be very inefficient. If at all possible, use
-- 'enumFromStepN' instead.
enumFromTo :: (Enum a, Monad m) => a -> a -> Bundle m v a
{-# INLINE_FUSED enumFromTo #-}
enumFromTo :: forall a (m :: * -> *) (v :: * -> *).
(Enum a, Monad m) =>
a -> a -> Bundle m v a
enumFromTo a
x a
y = [a] -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
[a] -> Bundle m v a
fromList [a
x .. a
y]

-- NOTE: We use (x+1) instead of (succ x) below because the latter checks for
-- overflow which can't happen here.

-- FIXME: add "too large" test for Int
enumFromTo_small :: (Integral a, Monad m) => a -> a -> Bundle m v a
{-# INLINE_FUSED enumFromTo_small #-}
enumFromTo_small :: forall a (m :: * -> *) (v :: * -> *).
(Integral a, Monad m) =>
a -> a -> Bundle m v a
enumFromTo_small a
x a
y = a
x a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` a
y a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((Maybe a -> m (Step (Maybe a) a)) -> Maybe a -> Stream m a
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream Maybe a -> m (Step (Maybe a) a)
step (a -> Maybe a
forall a. a -> Maybe a
Just a
x)) (Int -> Size
Exact Int
n)
  where
    n :: Int
n = (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 (a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
y Int -> Int -> Int
forall a. Num a => a -> a -> a
- a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
0

    {-# INLINE_INNER step #-}
    step :: Maybe a -> m (Step (Maybe a) a)
step Maybe a
Nothing              = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ Step (Maybe a) a
forall s a. Step s a
Done
    step (Just a
z) | a
z a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
y    = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a -> Step (Maybe a) a
forall a s. a -> s -> Step s a
Yield a
z Maybe a
forall a. Maybe a
Nothing
                  | a
z a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<  a
y    = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a -> Step (Maybe a) a
forall a s. a -> s -> Step s a
Yield a
z (a -> Maybe a
forall a. a -> Maybe a
Just (a
za -> a -> a
forall a. Num a => a -> a -> a
+a
1))
                  | Bool
otherwise = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ Step (Maybe a) a
forall s a. Step s a
Done

{-# RULES

"enumFromTo<Int8> [Bundle]"
  enumFromTo = enumFromTo_small :: Monad m => Int8 -> Int8 -> Bundle m v Int8

"enumFromTo<Int16> [Bundle]"
  enumFromTo = enumFromTo_small :: Monad m => Int16 -> Int16 -> Bundle m v Int16

"enumFromTo<Word8> [Bundle]"
  enumFromTo = enumFromTo_small :: Monad m => Word8 -> Word8 -> Bundle m v Word8

"enumFromTo<Word16> [Bundle]"
  enumFromTo = enumFromTo_small :: Monad m => Word16 -> Word16 -> Bundle m v Word16   #-}



#if WORD_SIZE_IN_BITS > 32

{-# RULES

"enumFromTo<Int32> [Bundle]"
  enumFromTo = enumFromTo_small :: Monad m => Int32 -> Int32 -> Bundle m v Int32

"enumFromTo<Word32> [Bundle]"
  enumFromTo = enumFromTo_small :: Monad m => Word32 -> Word32 -> Bundle m v Word32   #-}

#endif

-- NOTE: We could implement a generic "too large" test:
--
-- len x y | x > y = 0
--         | n > 0 && n <= fromIntegral (maxBound :: Int) = fromIntegral n
--         | otherwise = error
--   where
--     n = y-x+1
--
-- Alas, GHC won't eliminate unnecessary comparisons (such as n >= 0 for
-- unsigned types). See http://hackage.haskell.org/trac/ghc/ticket/3744
--

enumFromTo_int :: forall m v. (HasCallStack, Monad m) => Int -> Int -> Bundle m v Int
{-# INLINE_FUSED enumFromTo_int #-}
enumFromTo_int :: forall (m :: * -> *) (v :: * -> *).
(HasCallStack, Monad m) =>
Int -> Int -> Bundle m v Int
enumFromTo_int Int
x Int
y = Int
x Int -> Bundle m v Int -> Bundle m v Int
forall a b. a -> b -> b
`seq` Int
y Int -> Bundle m v Int -> Bundle m v Int
forall a b. a -> b -> b
`seq` Stream m Int -> Size -> Bundle m v Int
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((Maybe Int -> m (Step (Maybe Int) Int))
-> Maybe Int -> Stream m Int
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream Maybe Int -> m (Step (Maybe Int) Int)
step (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
x)) (Int -> Size
Exact (HasCallStack => Int -> Int -> Int
Int -> Int -> Int
len Int
x Int
y))
  where
    {-# INLINE [0] len #-}
    len :: HasCallStack => Int -> Int -> Int
    len :: HasCallStack => Int -> Int -> Int
len Int
u Int
v | Int
u Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
v     = Int
0
            | Bool
otherwise = Checks -> String -> Bool -> Int -> Int
forall a. HasCallStack => Checks -> String -> Bool -> a -> a
check Checks
Bounds String
"vector too large" (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) Int
n
      where
        n :: Int
n = Int
vInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
uInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1

    {-# INLINE_INNER step #-}
    step :: Maybe Int -> m (Step (Maybe Int) Int)
step Maybe Int
Nothing              = Step (Maybe Int) Int -> m (Step (Maybe Int) Int)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe Int) Int -> m (Step (Maybe Int) Int))
-> Step (Maybe Int) Int -> m (Step (Maybe Int) Int)
forall a b. (a -> b) -> a -> b
$ Step (Maybe Int) Int
forall s a. Step s a
Done
    step (Just Int
z) | Int
z Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
y    = Step (Maybe Int) Int -> m (Step (Maybe Int) Int)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe Int) Int -> m (Step (Maybe Int) Int))
-> Step (Maybe Int) Int -> m (Step (Maybe Int) Int)
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Int -> Step (Maybe Int) Int
forall a s. a -> s -> Step s a
Yield Int
z Maybe Int
forall a. Maybe a
Nothing
                  | Int
z Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<  Int
y    = Step (Maybe Int) Int -> m (Step (Maybe Int) Int)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe Int) Int -> m (Step (Maybe Int) Int))
-> Step (Maybe Int) Int -> m (Step (Maybe Int) Int)
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Int -> Step (Maybe Int) Int
forall a s. a -> s -> Step s a
Yield Int
z (Int -> Maybe Int
forall a. a -> Maybe a
Just (Int
zInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1))
                  | Bool
otherwise = Step (Maybe Int) Int -> m (Step (Maybe Int) Int)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe Int) Int -> m (Step (Maybe Int) Int))
-> Step (Maybe Int) Int -> m (Step (Maybe Int) Int)
forall a b. (a -> b) -> a -> b
$ Step (Maybe Int) Int
forall s a. Step s a
Done

enumFromTo_intlike :: forall m v a. (HasCallStack, Integral a, Monad m) => a -> a -> Bundle m v a
{-# INLINE_FUSED enumFromTo_intlike #-}
enumFromTo_intlike :: forall (m :: * -> *) (v :: * -> *) a.
(HasCallStack, Integral a, Monad m) =>
a -> a -> Bundle m v a
enumFromTo_intlike a
x a
y = a
x a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` a
y a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((Maybe a -> m (Step (Maybe a) a)) -> Maybe a -> Stream m a
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream Maybe a -> m (Step (Maybe a) a)
step (a -> Maybe a
forall a. a -> Maybe a
Just a
x)) (Int -> Size
Exact (a -> a -> Int
HasCallStack => a -> a -> Int
len a
x a
y))
  where
    {-# INLINE [0] len #-}
    len :: HasCallStack => a -> a -> Int
    len :: HasCallStack => a -> a -> Int
len a
u a
v | a
u a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
v     = Int
0
            | Bool
otherwise = Checks -> String -> Bool -> Int -> Int
forall a. HasCallStack => Checks -> String -> Bool -> a -> a
check Checks
Bounds String
"vector too large"
                          (a
n a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
0)
                        (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
n
      where
        n :: a
n = a
va -> a -> a
forall a. Num a => a -> a -> a
-a
ua -> a -> a
forall a. Num a => a -> a -> a
+a
1

    {-# INLINE_INNER step #-}
    step :: Maybe a -> m (Step (Maybe a) a)
step Maybe a
Nothing              = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ Step (Maybe a) a
forall s a. Step s a
Done
    step (Just a
z) | a
z a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
y    = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a -> Step (Maybe a) a
forall a s. a -> s -> Step s a
Yield a
z Maybe a
forall a. Maybe a
Nothing
                  | a
z a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<  a
y    = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a -> Step (Maybe a) a
forall a s. a -> s -> Step s a
Yield a
z (a -> Maybe a
forall a. a -> Maybe a
Just (a
za -> a -> a
forall a. Num a => a -> a -> a
+a
1))
                  | Bool
otherwise = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ Step (Maybe a) a
forall s a. Step s a
Done

{-# RULES

"enumFromTo<Int> [Bundle]"
  enumFromTo = enumFromTo_int :: Monad m => Int -> Int -> Bundle m v Int

#if WORD_SIZE_IN_BITS > 32

"enumFromTo<Int64> [Bundle]"
  enumFromTo = enumFromTo_intlike :: Monad m => Int64 -> Int64 -> Bundle m v Int64    #-}

#else

"enumFromTo<Int32> [Bundle]"
  enumFromTo = enumFromTo_intlike :: Monad m => Int32 -> Int32 -> Bundle m v Int32    #-}

#endif



enumFromTo_big_word :: forall m v a. (HasCallStack, Integral a, Monad m) => a -> a -> Bundle m v a
{-# INLINE_FUSED enumFromTo_big_word #-}
enumFromTo_big_word :: forall (m :: * -> *) (v :: * -> *) a.
(HasCallStack, Integral a, Monad m) =>
a -> a -> Bundle m v a
enumFromTo_big_word a
x a
y = a
x a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` a
y a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((Maybe a -> m (Step (Maybe a) a)) -> Maybe a -> Stream m a
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream Maybe a -> m (Step (Maybe a) a)
step (a -> Maybe a
forall a. a -> Maybe a
Just a
x)) (Int -> Size
Exact (a -> a -> Int
HasCallStack => a -> a -> Int
len a
x a
y))
  where
    {-# INLINE [0] len #-}
    len :: HasCallStack => a -> a -> Int
    len :: HasCallStack => a -> a -> Int
len a
u a
v | a
u a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
v     = Int
0
            | Bool
otherwise = Checks -> String -> Bool -> Int -> Int
forall a. HasCallStack => Checks -> String -> Bool -> a -> a
check Checks
Bounds String
"vector too large"
                          (a
n a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int
forall a. Bounded a => a
maxBound :: Int))
                        (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a
na -> a -> a
forall a. Num a => a -> a -> a
+a
1)
      where
        n :: a
n = a
va -> a -> a
forall a. Num a => a -> a -> a
-a
u

    {-# INLINE_INNER step #-}
    step :: Maybe a -> m (Step (Maybe a) a)
step Maybe a
Nothing              = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ Step (Maybe a) a
forall s a. Step s a
Done
    step (Just a
z) | a
z a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
y    = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a -> Step (Maybe a) a
forall a s. a -> s -> Step s a
Yield a
z Maybe a
forall a. Maybe a
Nothing
                  | a
z a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<  a
y    = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a -> Step (Maybe a) a
forall a s. a -> s -> Step s a
Yield a
z (a -> Maybe a
forall a. a -> Maybe a
Just (a
za -> a -> a
forall a. Num a => a -> a -> a
+a
1))
                  | Bool
otherwise = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ Step (Maybe a) a
forall s a. Step s a
Done

{-# RULES

"enumFromTo<Word> [Bundle]"
  enumFromTo = enumFromTo_big_word :: Monad m => Word -> Word -> Bundle m v Word

"enumFromTo<Word64> [Bundle]"
  enumFromTo = enumFromTo_big_word
                        :: Monad m => Word64 -> Word64 -> Bundle m v Word64

#if WORD_SIZE_IN_BITS == 32

"enumFromTo<Word32> [Bundle]"
  enumFromTo = enumFromTo_big_word
                        :: Monad m => Word32 -> Word32 -> Bundle m v Word32

#endif

"enumFromTo<Integer> [Bundle]"
  enumFromTo = enumFromTo_big_word
                        :: Monad m => Integer -> Integer -> Bundle m v Integer   #-}


#if WORD_SIZE_IN_BITS > 32

-- FIXME: the "too large" test is totally wrong
enumFromTo_big_int :: forall m v a. (HasCallStack, Integral a, Monad m) => a -> a -> Bundle m v a
{-# INLINE_FUSED enumFromTo_big_int #-}
enumFromTo_big_int :: forall (m :: * -> *) (v :: * -> *) a.
(HasCallStack, Integral a, Monad m) =>
a -> a -> Bundle m v a
enumFromTo_big_int a
x a
y = a
x a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` a
y a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((Maybe a -> m (Step (Maybe a) a)) -> Maybe a -> Stream m a
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream Maybe a -> m (Step (Maybe a) a)
step (a -> Maybe a
forall a. a -> Maybe a
Just a
x)) (Int -> Size
Exact (a -> a -> Int
HasCallStack => a -> a -> Int
len a
x a
y))
  where
    {-# INLINE [0] len #-}
    len :: HasCallStack => a -> a -> Int
    len :: HasCallStack => a -> a -> Int
len a
u a
v | a
u a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
v     = Int
0
            | Bool
otherwise = Checks -> String -> Bool -> Int -> Int
forall a. HasCallStack => Checks -> String -> Bool -> a -> a
check Checks
Bounds String
"vector too large"
                          (a
n a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
0 Bool -> Bool -> Bool
&& a
n a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<= Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int
forall a. Bounded a => a
maxBound :: Int))
                        (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
n
      where
        n :: a
n = a
va -> a -> a
forall a. Num a => a -> a -> a
-a
ua -> a -> a
forall a. Num a => a -> a -> a
+a
1

    {-# INLINE_INNER step #-}
    step :: Maybe a -> m (Step (Maybe a) a)
step Maybe a
Nothing              = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ Step (Maybe a) a
forall s a. Step s a
Done
    step (Just a
z) | a
z a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
y    = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a -> Step (Maybe a) a
forall a s. a -> s -> Step s a
Yield a
z Maybe a
forall a. Maybe a
Nothing
                  | a
z a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<  a
y    = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a -> Step (Maybe a) a
forall a s. a -> s -> Step s a
Yield a
z (a -> Maybe a
forall a. a -> Maybe a
Just (a
za -> a -> a
forall a. Num a => a -> a -> a
+a
1))
                  | Bool
otherwise = Step (Maybe a) a -> m (Step (Maybe a) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe a) a -> m (Step (Maybe a) a))
-> Step (Maybe a) a -> m (Step (Maybe a) a)
forall a b. (a -> b) -> a -> b
$ Step (Maybe a) a
forall s a. Step s a
Done


{-# RULES

"enumFromTo<Int64> [Bundle]"
  enumFromTo = enumFromTo_big_int :: Monad m => Int64 -> Int64 -> Bundle m v Int64   #-}



#endif

enumFromTo_char :: Monad m => Char -> Char -> Bundle m v Char
{-# INLINE_FUSED enumFromTo_char #-}
enumFromTo_char :: forall (m :: * -> *) (v :: * -> *).
Monad m =>
Char -> Char -> Bundle m v Char
enumFromTo_char Char
x Char
y = Char
x Char -> Bundle m v Char -> Bundle m v Char
forall a b. a -> b -> b
`seq` Char
y Char -> Bundle m v Char -> Bundle m v Char
forall a b. a -> b -> b
`seq` Stream m Char -> Size -> Bundle m v Char
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((Int -> m (Step Int Char)) -> Int -> Stream m Char
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream Int -> m (Step Int Char)
step Int
xn) (Int -> Size
Exact Int
n)
  where
    xn :: Int
xn = Char -> Int
ord Char
x
    yn :: Int
yn = Char -> Int
ord Char
y

    n :: Int
n = (Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
delay_inline Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0 (Int
yn Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
xn Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)

    {-# INLINE_INNER step #-}
    step :: Int -> m (Step Int Char)
step Int
zn | Int
zn Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
yn  = Step Int Char -> m (Step Int Char)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step Int Char -> m (Step Int Char))
-> Step Int Char -> m (Step Int Char)
forall a b. (a -> b) -> a -> b
$ Char -> Int -> Step Int Char
forall a s. a -> s -> Step s a
Yield (Int -> Char
unsafeChr Int
zn) (Int
znInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
            | Bool
otherwise = Step Int Char -> m (Step Int Char)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step Int Char -> m (Step Int Char))
-> Step Int Char -> m (Step Int Char)
forall a b. (a -> b) -> a -> b
$ Step Int Char
forall s a. Step s a
Done

{-# RULES

"enumFromTo<Char> [Bundle]"
  enumFromTo = enumFromTo_char   #-}



------------------------------------------------------------------------

-- Specialise enumFromTo for Float and Double.
-- Also, try to do something about pairs?

enumFromTo_double :: forall m v a. (HasCallStack, Monad m, Ord a, RealFrac a) => a -> a -> Bundle m v a
{-# INLINE_FUSED enumFromTo_double #-}
enumFromTo_double :: forall (m :: * -> *) (v :: * -> *) a.
(HasCallStack, Monad m, Ord a, RealFrac a) =>
a -> a -> Bundle m v a
enumFromTo_double a
n a
m = a
n a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` a
m a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ((a -> m (Step a a)) -> a -> Stream m a
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream a -> m (Step a a)
step a
ini) (Int -> Size
Max (a -> a -> Int
HasCallStack => a -> a -> Int
len a
n a
lim))
  where
    lim :: a
lim = a
m a -> a -> a
forall a. Num a => a -> a -> a
+ a
1a -> a -> a
forall a. Fractional a => a -> a -> a
/a
2 -- important to float out

    {-# INLINE [0] len #-}
    len :: HasCallStack => a -> a -> Int
    len :: HasCallStack => a -> a -> Int
len a
x a
y | a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
y     = Int
0
            | Bool
otherwise = Checks -> String -> Bool -> Int -> Int
forall a. HasCallStack => Checks -> String -> Bool -> a -> a
check Checks
Bounds String
"vector too large" (Integer
l Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
0) (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
l
      where
        l :: Integer
        l :: Integer
l = a -> Integer
forall b. Integral b => a -> b
forall a b. (RealFrac a, Integral b) => a -> b
truncate (a
ya -> a -> a
forall a. Num a => a -> a -> a
-a
x)Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
2

    {-# INLINE_INNER step #-}
-- GHC changed definition of Enum for Double in GHC8.6 so we have to
-- accommodate both definitions in order to preserve validity of
-- rewrite rule
--
--  ISSUE:  https://gitlab.haskell.org/ghc/ghc/issues/15081
--  COMMIT: https://gitlab.haskell.org/ghc/ghc/commit/4ffaf4b67773af4c72d92bb8b6c87b1a7d34ac0f
#if MIN_VERSION_base(4,12,0)
    ini :: a
ini = a
0
    step :: a -> m (Step a a)
step a
x | a
x' a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<= a
lim = Step a a -> m (Step a a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step a a -> m (Step a a)) -> Step a a -> m (Step a a)
forall a b. (a -> b) -> a -> b
$ a -> a -> Step a a
forall a s. a -> s -> Step s a
Yield a
x' (a
xa -> a -> a
forall a. Num a => a -> a -> a
+a
1)
           | Bool
otherwise = Step a a -> m (Step a a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step a a -> m (Step a a)) -> Step a a -> m (Step a a)
forall a b. (a -> b) -> a -> b
$ Step a a
forall s a. Step s a
Done
           where
             x' :: a
x' = a
x a -> a -> a
forall a. Num a => a -> a -> a
+ a
n
#else
    ini = n
    step x | x <= lim  = return $ Yield x (x+1)
           | otherwise = return $ Done
#endif

{-# RULES

"enumFromTo<Double> [Bundle]"
  enumFromTo = enumFromTo_double :: Monad m => Double -> Double -> Bundle m v Double

"enumFromTo<Float> [Bundle]"
  enumFromTo = enumFromTo_double :: Monad m => Float -> Float -> Bundle m v Float   #-}



------------------------------------------------------------------------

-- | Enumerate values with a given step.
--
-- /WARNING:/ This operation is very inefficient. If at all possible, use
-- 'enumFromStepN' instead.
enumFromThenTo :: (Enum a, Monad m) => a -> a -> a -> Bundle m v a
{-# INLINE_FUSED enumFromThenTo #-}
enumFromThenTo :: forall a (m :: * -> *) (v :: * -> *).
(Enum a, Monad m) =>
a -> a -> a -> Bundle m v a
enumFromThenTo a
x a
y a
z = [a] -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
[a] -> Bundle m v a
fromList [a
x, a
y .. a
z]

-- FIXME: Specialise enumFromThenTo.

-- Conversions
-- -----------

-- | Convert a 'Bundle' to a list
toList :: Monad m => Bundle m v a -> m [a]
{-# INLINE toList #-}
toList :: forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> m [a]
toList = (a -> [a] -> [a]) -> [a] -> Bundle m v a -> m [a]
forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> b) -> b -> Bundle m v a -> m b
foldr (:) []

-- | Convert a list to a 'Bundle'
fromList :: Monad m => [a] -> Bundle m v a
{-# INLINE fromList #-}
fromList :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
[a] -> Bundle m v a
fromList [a]
xs = Size -> [a] -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Size -> [a] -> Bundle m v a
unsafeFromList Size
Unknown [a]
xs

-- | Convert the first @n@ elements of a list to a 'Bundle'
fromListN :: Monad m => Int -> [a] -> Bundle m v a
{-# INLINE_FUSED fromListN #-}
fromListN :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Int -> [a] -> Bundle m v a
fromListN Int
n [a]
xs = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream (Int -> [a] -> Stream m a
forall (m :: * -> *) a. Monad m => Int -> [a] -> Stream m a
S.fromListN Int
n [a]
xs) (Int -> Size
Max ((Int -> Int -> Int) -> Int -> Int -> Int
forall a b. (a -> b) -> a -> b
delay_inline Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
n Int
0))

-- | Convert a list to a 'Bundle' with the given 'Size' hint.
unsafeFromList :: Monad m => Size -> [a] -> Bundle m v a
{-# INLINE_FUSED unsafeFromList #-}
unsafeFromList :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Size -> [a] -> Bundle m v a
unsafeFromList Size
sz [a]
xs = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream ([a] -> Stream m a
forall (m :: * -> *) a. Monad m => [a] -> Stream m a
S.fromList [a]
xs) Size
sz

fromVector :: (Monad m, Vector v a) => v a -> Bundle m v a
{-# INLINE_FUSED fromVector #-}
fromVector :: forall (m :: * -> *) (v :: * -> *) a.
(Monad m, Vector v a) =>
v a -> Bundle m v a
fromVector v a
v = v a
v v a -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` Int
n Int -> Bundle m v a -> Bundle m v a
forall a b. a -> b -> b
`seq` Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
forall (m :: * -> *) (v :: * -> *) a.
Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
Bundle ((Int -> m (Step Int a)) -> Int -> Stream m a
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream Int -> m (Step Int a)
step Int
0)
                                      ((Bool -> m (Step Bool (Chunk v a))) -> Bool -> Stream m (Chunk v a)
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream Bool -> m (Step Bool (Chunk v a))
vstep Bool
True)
                                      (v a -> Maybe (v a)
forall a. a -> Maybe a
Just v a
v)
                                      (Int -> Size
Exact Int
n)
  where
    n :: Int
n = v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
basicLength v a
v

    {-# INLINE step #-}
    step :: Int -> m (Step Int a)
step Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
n = Step Int a -> m (Step Int a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Step Int a
forall s a. Step s a
Done
           | Bool
otherwise = case v a -> Int -> Box a
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
basicUnsafeIndexM v a
v Int
i of
                           Box a
x -> Step Int a -> m (Step Int a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step Int a -> m (Step Int a)) -> Step Int a -> m (Step Int a)
forall a b. (a -> b) -> a -> b
$ a -> Int -> Step Int a
forall a s. a -> s -> Step s a
Yield a
x (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)


    {-# INLINE vstep #-}
    vstep :: Bool -> m (Step Bool (Chunk v a))
vstep Bool
True  = Step Bool (Chunk v a) -> m (Step Bool (Chunk v a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Chunk v a -> Bool -> Step Bool (Chunk v a)
forall a s. a -> s -> Step s a
Yield (Int
-> (forall (m :: * -> *).
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m ())
-> Chunk v a
forall (v :: * -> *) a.
Int
-> (forall (m :: * -> *).
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m ())
-> Chunk v a
Chunk (v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
basicLength v a
v) (\Mutable v (PrimState m) a
mv -> ST (PrimState m) () -> m ()
forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a
stToPrim (ST (PrimState m) () -> m ()) -> ST (PrimState m) () -> m ()
forall a b. (a -> b) -> a -> b
$ Mutable v (PrimState m) a -> v a -> ST (PrimState m) ()
forall s. Mutable v s a -> v a -> ST s ()
forall (v :: * -> *) a s.
Vector v a =>
Mutable v s a -> v a -> ST s ()
basicUnsafeCopy Mutable v (PrimState m) a
mv v a
v)) Bool
False)
    vstep Bool
False = Step Bool (Chunk v a) -> m (Step Bool (Chunk v a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Step Bool (Chunk v a)
forall s a. Step s a
Done

fromVectors :: forall m v a. (Monad m, Vector v a) => [v a] -> Bundle m v a
{-# INLINE_FUSED fromVectors #-}
fromVectors :: forall (m :: * -> *) (v :: * -> *) a.
(Monad m, Vector v a) =>
[v a] -> Bundle m v a
fromVectors [v a]
us = Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
forall (m :: * -> *) (v :: * -> *) a.
Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
Bundle ((Either [v a] (v a, Int, [v a])
 -> m (Step (Either [v a] (v a, Int, [v a])) a))
-> Either [v a] (v a, Int, [v a]) -> Stream m a
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream Either [v a] (v a, Int, [v a])
-> m (Step (Either [v a] (v a, Int, [v a])) a)
forall {m :: * -> *} {v :: * -> *} {a}.
(Monad m, Vector v a) =>
Either [v a] (v a, Int, [v a])
-> m (Step (Either [v a] (v a, Int, [v a])) a)
pstep ([v a] -> Either [v a] (v a, Int, [v a])
forall a b. a -> Either a b
Left [v a]
us))
                        (([v a] -> m (Step [v a] (Chunk v a)))
-> [v a] -> Stream m (Chunk v a)
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream HasCallStack => [v a] -> m (Step [v a] (Chunk v a))
[v a] -> m (Step [v a] (Chunk v a))
vstep [v a]
us)
                        Maybe (v a)
forall a. Maybe a
Nothing
                        (Int -> Size
Exact Int
n)
  where
    n :: Int
n = (Int -> v a -> Int) -> Int -> [v a] -> Int
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' (\Int
k v a
v -> Int
k Int -> Int -> Int
forall a. Num a => a -> a -> a
+ v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
basicLength v a
v) Int
0 [v a]
us

    pstep :: Either [v a] (v a, Int, [v a])
-> m (Step (Either [v a] (v a, Int, [v a])) a)
pstep (Left []) = Step (Either [v a] (v a, Int, [v a])) a
-> m (Step (Either [v a] (v a, Int, [v a])) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Step (Either [v a] (v a, Int, [v a])) a
forall s a. Step s a
Done
    pstep (Left (v a
v:[v a]
vs)) = v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
basicLength v a
v Int
-> m (Step (Either [v a] (v a, Int, [v a])) a)
-> m (Step (Either [v a] (v a, Int, [v a])) a)
forall a b. a -> b -> b
`seq` Step (Either [v a] (v a, Int, [v a])) a
-> m (Step (Either [v a] (v a, Int, [v a])) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either [v a] (v a, Int, [v a])
-> Step (Either [v a] (v a, Int, [v a])) a
forall s a. s -> Step s a
Skip ((v a, Int, [v a]) -> Either [v a] (v a, Int, [v a])
forall a b. b -> Either a b
Right (v a
v,Int
0,[v a]
vs)))

    pstep (Right (v a
v,Int
i,[v a]
vs))
      | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
basicLength v a
v = Step (Either [v a] (v a, Int, [v a])) a
-> m (Step (Either [v a] (v a, Int, [v a])) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Either [v a] (v a, Int, [v a])) a
 -> m (Step (Either [v a] (v a, Int, [v a])) a))
-> Step (Either [v a] (v a, Int, [v a])) a
-> m (Step (Either [v a] (v a, Int, [v a])) a)
forall a b. (a -> b) -> a -> b
$ Either [v a] (v a, Int, [v a])
-> Step (Either [v a] (v a, Int, [v a])) a
forall s a. s -> Step s a
Skip ([v a] -> Either [v a] (v a, Int, [v a])
forall a b. a -> Either a b
Left [v a]
vs)
      | Bool
otherwise          = case v a -> Int -> Box a
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
basicUnsafeIndexM v a
v Int
i of
                               Box a
x -> Step (Either [v a] (v a, Int, [v a])) a
-> m (Step (Either [v a] (v a, Int, [v a])) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Either [v a] (v a, Int, [v a])) a
 -> m (Step (Either [v a] (v a, Int, [v a])) a))
-> Step (Either [v a] (v a, Int, [v a])) a
-> m (Step (Either [v a] (v a, Int, [v a])) a)
forall a b. (a -> b) -> a -> b
$ a
-> Either [v a] (v a, Int, [v a])
-> Step (Either [v a] (v a, Int, [v a])) a
forall a s. a -> s -> Step s a
Yield a
x ((v a, Int, [v a]) -> Either [v a] (v a, Int, [v a])
forall a b. b -> Either a b
Right (v a
v,Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1,[v a]
vs))

    -- FIXME: work around bug in GHC 7.6.1
    vstep :: HasCallStack => [v a] -> m (Step [v a] (Chunk v a))
    vstep :: HasCallStack => [v a] -> m (Step [v a] (Chunk v a))
vstep [] = Step [v a] (Chunk v a) -> m (Step [v a] (Chunk v a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Step [v a] (Chunk v a)
forall s a. Step s a
Done
    vstep (v a
v:[v a]
vs) = Step [v a] (Chunk v a) -> m (Step [v a] (Chunk v a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step [v a] (Chunk v a) -> m (Step [v a] (Chunk v a)))
-> Step [v a] (Chunk v a) -> m (Step [v a] (Chunk v a))
forall a b. (a -> b) -> a -> b
$ Chunk v a -> [v a] -> Step [v a] (Chunk v a)
forall a s. a -> s -> Step s a
Yield (Int
-> (forall (m :: * -> *).
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m ())
-> Chunk v a
forall (v :: * -> *) a.
Int
-> (forall (m :: * -> *).
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m ())
-> Chunk v a
Chunk (v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
basicLength v a
v)
                                         (\Mutable v (PrimState m) a
mv -> Checks -> String -> Bool -> m () -> m ()
forall a. HasCallStack => Checks -> String -> Bool -> a -> a
check
                                                 Checks
Internal
                                                 String
"length mismatch"
                                                 (Mutable v (PrimState m) a -> Int
forall s. Mutable v s a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
M.basicLength Mutable v (PrimState m) a
mv Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
basicLength v a
v)
                                                 (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ ST (PrimState m) () -> m ()
forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a
stToPrim (ST (PrimState m) () -> m ()) -> ST (PrimState m) () -> m ()
forall a b. (a -> b) -> a -> b
$ Mutable v (PrimState m) a -> v a -> ST (PrimState m) ()
forall s. Mutable v s a -> v a -> ST s ()
forall (v :: * -> *) a s.
Vector v a =>
Mutable v s a -> v a -> ST s ()
basicUnsafeCopy Mutable v (PrimState m) a
mv v a
v)) [v a]
vs


concatVectors :: (Monad m, Vector v a) => Bundle m u (v a) -> Bundle m v a
{-# INLINE_FUSED concatVectors #-}
concatVectors :: forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
(Monad m, Vector v a) =>
Bundle m u (v a) -> Bundle m v a
concatVectors Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream s -> m (Step s (v a))
step s
t}
  = Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
forall (m :: * -> *) (v :: * -> *) a.
Stream m a
-> Stream m (Chunk v a) -> Maybe (v a) -> Size -> Bundle m v a
Bundle ((Either s (v a, Int, s) -> m (Step (Either s (v a, Int, s)) a))
-> Either s (v a, Int, s) -> Stream m a
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream Either s (v a, Int, s) -> m (Step (Either s (v a, Int, s)) a)
pstep (s -> Either s (v a, Int, s)
forall a b. a -> Either a b
Left s
t))
           ((s -> m (Step s (Chunk v a))) -> s -> Stream m (Chunk v a)
forall (m :: * -> *) a s. (s -> m (Step s a)) -> s -> Stream m a
Stream s -> m (Step s (Chunk v a))
vstep s
t)
           Maybe (v a)
forall a. Maybe a
Nothing
           Size
Unknown
  where
    pstep :: Either s (v a, Int, s) -> m (Step (Either s (v a, Int, s)) a)
pstep (Left s
s) = do
      Step s (v a)
r <- s -> m (Step s (v a))
step s
s
      case Step s (v a)
r of
        Yield v a
v s
s' -> v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
basicLength v a
v Int
-> m (Step (Either s (v a, Int, s)) a)
-> m (Step (Either s (v a, Int, s)) a)
forall a b. a -> b -> b
`seq` Step (Either s (v a, Int, s)) a
-> m (Step (Either s (v a, Int, s)) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either s (v a, Int, s) -> Step (Either s (v a, Int, s)) a
forall s a. s -> Step s a
Skip ((v a, Int, s) -> Either s (v a, Int, s)
forall a b. b -> Either a b
Right (v a
v,Int
0,s
s')))
        Skip    s
s' -> Step (Either s (v a, Int, s)) a
-> m (Step (Either s (v a, Int, s)) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either s (v a, Int, s) -> Step (Either s (v a, Int, s)) a
forall s a. s -> Step s a
Skip (s -> Either s (v a, Int, s)
forall a b. a -> Either a b
Left s
s'))
        Step s (v a)
Done       -> Step (Either s (v a, Int, s)) a
-> m (Step (Either s (v a, Int, s)) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Step (Either s (v a, Int, s)) a
forall s a. Step s a
Done

    pstep (Right (v a
v,Int
i,s
s))
      | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
basicLength v a
v = Step (Either s (v a, Int, s)) a
-> m (Step (Either s (v a, Int, s)) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either s (v a, Int, s) -> Step (Either s (v a, Int, s)) a
forall s a. s -> Step s a
Skip (s -> Either s (v a, Int, s)
forall a b. a -> Either a b
Left s
s))
      | Bool
otherwise          = case v a -> Int -> Box a
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
basicUnsafeIndexM v a
v Int
i of
                               Box a
x -> Step (Either s (v a, Int, s)) a
-> m (Step (Either s (v a, Int, s)) a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> Either s (v a, Int, s) -> Step (Either s (v a, Int, s)) a
forall a s. a -> s -> Step s a
Yield a
x ((v a, Int, s) -> Either s (v a, Int, s)
forall a b. b -> Either a b
Right (v a
v,Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1,s
s)))


    vstep :: s -> m (Step s (Chunk v a))
vstep s
s = do
      Step s (v a)
r <- s -> m (Step s (v a))
step s
s
      case Step s (v a)
r of
        Yield v a
v s
s' -> Step s (Chunk v a) -> m (Step s (Chunk v a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Chunk v a -> s -> Step s (Chunk v a)
forall a s. a -> s -> Step s a
Yield (Int
-> (forall (m :: * -> *).
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m ())
-> Chunk v a
forall (v :: * -> *) a.
Int
-> (forall (m :: * -> *).
    (PrimMonad m, Vector v a) =>
    Mutable v (PrimState m) a -> m ())
-> Chunk v a
Chunk (v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
basicLength v a
v)
                                           (\Mutable v (PrimState m) a
mv -> Checks -> String -> Bool -> m () -> m ()
forall a. HasCallStack => Checks -> String -> Bool -> a -> a
check
                                                   Checks
Internal
                                                   String
"length mismatch"
                                                   (Mutable v (PrimState m) a -> Int
forall s. Mutable v s a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
M.basicLength Mutable v (PrimState m) a
mv Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
basicLength v a
v)
                                                   (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ ST (PrimState m) () -> m ()
forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a
stToPrim (ST (PrimState m) () -> m ()) -> ST (PrimState m) () -> m ()
forall a b. (a -> b) -> a -> b
$ Mutable v (PrimState m) a -> v a -> ST (PrimState m) ()
forall s. Mutable v s a -> v a -> ST s ()
forall (v :: * -> *) a s.
Vector v a =>
Mutable v s a -> v a -> ST s ()
basicUnsafeCopy Mutable v (PrimState m) a
mv v a
v)) s
s')
        Skip    s
s' -> Step s (Chunk v a) -> m (Step s (Chunk v a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (s -> Step s (Chunk v a)
forall s a. s -> Step s a
Skip s
s')
        Step s (v a)
Done       -> Step s (Chunk v a) -> m (Step s (Chunk v a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Step s (Chunk v a)
forall s a. Step s a
Done

reVector :: Monad m => Bundle m u a -> Bundle m v a
{-# INLINE_FUSED reVector #-}
reVector :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *).
Monad m =>
Bundle m u a -> Bundle m v a
reVector Bundle{sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
sElems = Stream m a
s, sSize :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
sSize = Size
n} = Stream m a -> Size -> Bundle m v a
forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
fromStream Stream m a
s Size
n

{-# RULES

"reVector [Vector]"
  reVector = id

"reVector/reVector [Vector]" forall s.
  reVector (reVector s) = s   #-}