(original) (raw)

{-# LANGUAGE BangPatterns #-} {-# LANGUAGE CPP #-} {-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-}

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

size, sized,

length, null,

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

head, last, (!!), (!?),

slice, init, tail, take, drop,

map, mapM, mapM_, trans, unbox, concatMap, flatten,

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

eqBy, cmpBy,

filter, filterM, mapMaybeM, takeWhile, takeWhileM, dropWhile, dropWhileM,

elem, notElem, find, findM, findIndex, findIndexM,

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

and, or, concatMapM,

unfoldr, unfoldrM, unfoldrN, unfoldrNM, unfoldrExactN, unfoldrExactNM, iterateN, iterateNM,

prescanl, prescanlM, prescanl', prescanlM', postscanl, postscanlM, postscanl', postscanlM', scanl, scanlM, scanl', scanlM', scanl1, scanl1M, scanl1', scanl1M',

enumFromStepN, enumFromTo, enumFromThenTo,

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 ())

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 }

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 :: 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

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 :: 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

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

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 :: 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 :: 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

replicateM :: Monad m => Int -> m a -> Bundle m v a {-# INLINE_FUSED replicateM #-}

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)

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))

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

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 ++

(++) :: 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)

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 :: 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 !!

(!!) :: 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 !?

(!?) :: 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

slice :: Monad m => Int
-> Int
-> 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)

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)

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)

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)

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))

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 :: 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)

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

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

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

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

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

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)

{-# RULES

"zipWithM xs xs [Vector.Bundle]" forall f xs. zipWithM f (lift xs) (lift xs) = mapM ([x](#local-6989586621679209589) -> 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 (,,,,,)

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

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)

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)

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)

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)

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)

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)

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)

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)

infix 4 elem

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

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

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)

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

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)

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

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))

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

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

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))

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

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

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))

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

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'

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))

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

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'

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))

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

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))

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

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

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

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)

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

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)

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

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)

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))

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))

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

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))

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

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))

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

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))

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

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))

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

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))

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

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))

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)

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))

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

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))

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

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))

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]

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 [Bundle]" enumFromTo = enumFromTo_small :: Monad m => Int8 -> Int8 -> Bundle m v Int8

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

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

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

#if WORD_SIZE_IN_BITS > 32

{-# RULES

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

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

#endif

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 [Bundle]" enumFromTo = enumFromTo_int :: Monad m => Int -> Int -> Bundle m v Int

#if WORD_SIZE_IN_BITS > 32

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

#else

"enumFromTo [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 [Bundle]" enumFromTo = enumFromTo_big_word :: Monad m => Word -> Word -> Bundle m v Word

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

#if WORD_SIZE_IN_BITS == 32

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

#endif

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

#if WORD_SIZE_IN_BITS > 32

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 [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

{-# 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 [Bundle]" enumFromTo = enumFromTo_char #-}

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

  {-# 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 #-}

#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 [Bundle]" enumFromTo = enumFromTo_double :: Monad m => Double -> Double -> Bundle m v Double

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

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]

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 (:) []

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

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))

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](#local-6989586621679210505) #-}
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](#local-6989586621679210506) #-}
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](#local-6989586621679210531) (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))

[vstep](#local-6989586621679210532) :: HasCallStack => [[v](#local-6989586621679209133) [a](#local-6989586621679209134)] -> [m](#local-6989586621679209132) (Step [[v](#local-6989586621679209133) [a](#local-6989586621679209134)] ([Chunk](Data.Vector.Fusion.Bundle.Monadic.html#Chunk) [v](#local-6989586621679209133) [a](#local-6989586621679209134)))
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](#local-6989586621679210606) (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 #-}