{-# LANGUAGE BangPatterns #-}{-# LANGUAGE CPP #-}{-# LANGUAGE FlexibleInstances #-}{-# LANGUAGE RankNTypes #-}-- |-- Module : Data.Vector.Fusion.Bundle-- Copyright : (c) Roman Leshchinskiy 2008-2010-- Alexey Kuleshevich 2020-2022-- Aleksey Khudyakov 2020-2022-- Andrew Lelechenko 2020-2022-- License : BSD-style---- Maintainer : Haskell Libraries Team <libraries@haskell.org>-- Stability : experimental-- Portability : non-portable---- Bundles for stream fusion--moduleData.Vector.Fusion.Bundle(-- * TypesStep(..),Chunk (..),Bundle ,MBundle ,-- * In-place markersinplace ,-- * Size hintssize ,sized ,-- * Length informationlength ,null ,-- * Constructionempty ,singleton ,cons ,snoc ,replicate ,generate ,(++) ,-- * Accessing individual elementshead ,last ,(!!) ,(!?) ,-- * Substreamsslice ,init ,tail ,take ,drop ,-- * Mappingmap ,concatMap ,flatten ,unbox ,-- * Zippingindexed ,indexedR ,zipWith ,zipWith3 ,zipWith4 ,zipWith5 ,zipWith6 ,zip ,zip3 ,zip4 ,zip5 ,zip6 ,-- * Filteringfilter ,takeWhile ,dropWhile ,-- * Searchingelem ,notElem ,find ,findIndex ,-- * Foldingfoldl ,foldl1 ,foldl' ,foldl1' ,foldr ,foldr1 ,-- * Specialised foldsand ,or ,-- * Unfoldingunfoldr ,unfoldrN ,unfoldrExactN ,iterateN ,-- * Scansprescanl ,prescanl' ,postscanl ,postscanl' ,scanl ,scanl' ,scanl1 ,scanl1' ,-- * EnumerationsenumFromStepN ,enumFromTo ,enumFromThenTo ,-- * ConversionstoList ,fromList ,fromListN ,unsafeFromList ,lift ,fromVector ,reVector ,fromVectors ,concatVectors ,-- * Monadic combinatorsmapM ,mapM_ ,zipWithM ,zipWithM_ ,filterM ,mapMaybeM ,foldM ,fold1M ,foldM' ,fold1M' ,eq ,cmp ,eqBy ,cmpBy )whereimportData.Vector.Generic.Base (Vector )importData.Vector.Fusion.Bundle.Size importData.Vector.Fusion.Util importData.Vector.Fusion.Stream.Monadic (Stream(..),Step(..))importData.Vector.Fusion.Bundle.Monadic (Chunk (..),lift )importqualifiedData.Vector.Fusion.Bundle.Monadic asMimportqualifiedData.Vector.Fusion.Stream.Monadic asSimportPrelude(Eq,Ord,Num,Enum,Monad,Bool,Ordering,Int,Maybe,compare,return,seq,(==),(.))importData.Functor.Classes(Eq1(..),Ord1(..))importGHC.Base(build)-- Data.Vector.Internal.Check is unused
#define NOT_VECTOR_MODULE
#include "vector.h"
-- | The type of pure streamstypeBundle =M.Bundle Id -- | Alternative name for monadic streamstypeMBundle =M.Bundle inplace ::(forallm .Monadm =>S.Streamm a ->S.Streamm b )->(Size ->Size )->Bundle v a ->Bundle v b {-# INLINE_FUSED inplace #-}inplace :: forall a b (v :: * -> *).
(forall (m :: * -> *). Monad m => Stream m a -> Stream m b)
-> (Size -> Size) -> Bundle v a -> Bundle v b
inplace forall (m :: * -> *). Monad m => Stream m a -> Stream m b
f Size -> Size
g Bundle v a
b =Bundle v a
b seq :: forall a b. a -> b -> b
`seq`forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Stream m a -> Size -> Bundle m v a
M.fromStream (forall (m :: * -> *). Monad m => Stream m a -> Stream m b
f (forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
M.elements Bundle v a
b ))(Size -> Size
g (forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
M.size Bundle v a
b )){-# RULES"inplace/inplace [Vector]"forall(f1 ::forallm .Monadm =>S.Streamm a ->S.Streamm a )(f2 ::forallm .Monadm =>S.Streamm a ->S.Streamm a )g1 g2 s .inplace f1 g1 (inplace f2 g2 s )=inplace (f1 .f2 )(g1 .g2 )s #-}-- | 'Size' hint of a 'Bundle'size ::Bundle v a ->Size {-# INLINEsize #-}size :: forall (v :: * -> *) a. Bundle v a -> Size
size =forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Size
M.size -- | Attach a 'Size' hint to a 'Bundle'sized ::Bundle v a ->Size ->Bundle v a {-# INLINEsized #-}sized :: forall (v :: * -> *) a. Bundle v a -> Size -> Bundle v a
sized =forall (m :: * -> *) (v :: * -> *) a.
Bundle m v a -> Size -> Bundle m v a
M.sized -- Length-- -------- | Length of a 'Bundle'length ::Bundle v a ->Int{-# INLINElength #-}length :: forall (v :: * -> *) a. Bundle v a -> Int
length =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> m Int
M.length -- | Check if a 'Bundle' is emptynull ::Bundle v a ->Bool{-# INLINEnull #-}null :: forall (v :: * -> *) a. Bundle v a -> Bool
null =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> m Bool
M.null -- Construction-- -------------- | Empty 'Bundle'empty ::Bundle v a {-# INLINEempty #-}empty :: forall (v :: * -> *) a. Bundle v a
empty =forall (m :: * -> *) (v :: * -> *) a. Monad m => Bundle m v a
M.empty -- | Singleton 'Bundle'singleton ::a ->Bundle v a {-# INLINEsingleton #-}singleton :: forall a (v :: * -> *). a -> Bundle v a
singleton =forall (m :: * -> *) a (v :: * -> *). Monad m => a -> Bundle m v a
M.singleton -- | Replicate a value to a given lengthreplicate ::Int->a ->Bundle v a {-# INLINEreplicate #-}replicate :: forall a (v :: * -> *). Int -> a -> Bundle v a
replicate =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Int -> a -> Bundle m v a
M.replicate -- | Generate a stream from its indicesgenerate ::Int->(Int->a )->Bundle v a {-# INLINEgenerate #-}generate :: forall a (v :: * -> *). Int -> (Int -> a) -> Bundle v a
generate =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Int -> (Int -> a) -> Bundle m v a
M.generate -- | Prepend an elementcons ::a ->Bundle v a ->Bundle v a {-# INLINEcons #-}cons :: forall a (v :: * -> *). a -> Bundle v a -> Bundle v a
cons =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
a -> Bundle m v a -> Bundle m v a
M.cons -- | Append an elementsnoc ::Bundle v a ->a ->Bundle v a {-# INLINEsnoc #-}snoc :: forall (v :: * -> *) a. Bundle v a -> a -> Bundle v a
snoc =forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> a -> Bundle m v a
M.snoc infixr5++ -- | Concatenate two 'Bundle's(++) ::Bundle v a ->Bundle v a ->Bundle v a {-# INLINE(++)#-}++ :: forall (v :: * -> *) a. Bundle v a -> Bundle v a -> Bundle v a
(++) =forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Bundle m v a -> Bundle m v a
(M.++) -- Accessing elements-- -------------------- | First element of the 'Bundle' or error if emptyhead ::Bundle v a ->a {-# INLINEhead #-}head :: forall (v :: * -> *) a. Bundle v a -> a
head =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> m a
M.head -- | Last element of the 'Bundle' or error if emptylast ::Bundle v a ->a {-# INLINElast #-}last :: forall (v :: * -> *) a. Bundle v a -> a
last =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> m a
M.last infixl9!! -- | Element at the given position(!!) ::Bundle v a ->Int->a {-# INLINE(!!)#-}Bundle v a
s !! :: forall (v :: * -> *) a. Bundle v a -> Int -> a
!! Int
i =forall a. Id a -> a
unId (Bundle v a
s forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Int -> m a
M.!! Int
i )infixl9!? -- | Element at the given position or 'Nothing' if out of bounds(!?) ::Bundle v a ->Int->Maybea {-# INLINE(!?)#-}Bundle v a
s !? :: forall (v :: * -> *) a. Bundle v a -> Int -> Maybe a
!? Int
i =forall a. Id a -> a
unId (Bundle v a
s forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Int -> m (Maybe a)
M.!? Int
i )-- Substreams-- ------------ | Extract a substream of the given length starting at the given position.slice ::Int-- ^ starting index->Int-- ^ length->Bundle v a ->Bundle v a {-# INLINEslice #-}slice :: forall (v :: * -> *) a. Int -> Int -> Bundle v a -> Bundle v a
slice =forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Int -> Int -> Bundle m v a -> Bundle m v a
M.slice -- | All but the last elementinit ::Bundle v a ->Bundle v a {-# INLINEinit #-}init :: forall (v :: * -> *) a. Bundle v a -> Bundle v a
init =forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Bundle m v a
M.init -- | All but the first elementtail ::Bundle v a ->Bundle v a {-# INLINEtail #-}tail :: forall (v :: * -> *) a. Bundle v a -> Bundle v a
tail =forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Bundle m v a
M.tail -- | The first @n@ elementstake ::Int->Bundle v a ->Bundle v a {-# INLINEtake #-}take :: forall (v :: * -> *) a. Int -> Bundle v a -> Bundle v a
take =forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Int -> Bundle m v a -> Bundle m v a
M.take -- | All but the first @n@ elementsdrop ::Int->Bundle v a ->Bundle v a {-# INLINEdrop #-}drop :: forall (v :: * -> *) a. Int -> Bundle v a -> Bundle v a
drop =forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Int -> Bundle m v a -> Bundle m v a
M.drop -- Mapping-- ----------------- | Map a function over a 'Bundle'map ::(a ->b )->Bundle v a ->Bundle v b {-# INLINEmap #-}map :: forall a b (v :: * -> *). (a -> b) -> Bundle v a -> Bundle v b
map =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b) -> Bundle m v a -> Bundle m v b
M.map unbox ::Bundle v (Boxa )->Bundle v a {-# INLINEunbox #-}unbox :: forall (v :: * -> *) a. Bundle v (Box a) -> Bundle v a
unbox =forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v (Box a) -> Bundle m v a
M.unbox concatMap ::(a ->Bundle v b )->Bundle v a ->Bundle v b {-# INLINEconcatMap #-}concatMap :: forall a (v :: * -> *) b.
(a -> Bundle v b) -> Bundle v a -> Bundle v b
concatMap =forall (m :: * -> *) a (v :: * -> *) b.
Monad m =>
(a -> Bundle m v b) -> Bundle m v a -> Bundle m v b
M.concatMap -- Zipping-- --------- | Pair each element in a 'Bundle' with its indexindexed ::Bundle v a ->Bundle v (Int,a ){-# INLINEindexed #-}indexed :: forall (v :: * -> *) a. Bundle v a -> Bundle v (Int, a)
indexed =forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle m v a -> Bundle m v (Int, a)
M.indexed -- | Pair each element in a 'Bundle' with its index, starting from the right-- and counting downindexedR ::Int->Bundle v a ->Bundle v (Int,a ){-# INLINE_FUSED indexedR #-}indexedR :: forall (v :: * -> *) a. Int -> Bundle v a -> Bundle v (Int, a)
indexedR =forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Int -> Bundle m v a -> Bundle m v (Int, a)
M.indexedR -- | Zip two 'Bundle's with the given functionzipWith ::(a ->b ->c )->Bundle v a ->Bundle v b ->Bundle v c {-# INLINEzipWith #-}zipWith :: forall a b c (v :: * -> *).
(a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c
zipWith =forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
M.zipWith -- | Zip three 'Bundle's with the given functionzipWith3 ::(a ->b ->c ->d )->Bundle v a ->Bundle v b ->Bundle v c ->Bundle v d {-# INLINEzipWith3 #-}zipWith3 :: forall a b c d (v :: * -> *).
(a -> b -> c -> d)
-> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d
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
M.zipWith3 zipWith4 ::(a ->b ->c ->d ->e )->Bundle v a ->Bundle v b ->Bundle v c ->Bundle v d ->Bundle v e {-# INLINEzipWith4 #-}zipWith4 :: forall a b c d e (v :: * -> *).
(a -> b -> c -> d -> e)
-> Bundle v a
-> Bundle v b
-> Bundle v c
-> Bundle v d
-> Bundle v e
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
M.zipWith4 zipWith5 ::(a ->b ->c ->d ->e ->f )->Bundle v a ->Bundle v b ->Bundle v c ->Bundle v d ->Bundle v e ->Bundle v f {-# INLINEzipWith5 #-}zipWith5 :: forall a b c d e f (v :: * -> *).
(a -> b -> c -> d -> e -> f)
-> Bundle v a
-> Bundle v b
-> Bundle v c
-> Bundle v d
-> Bundle v e
-> Bundle v f
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
M.zipWith5 zipWith6 ::(a ->b ->c ->d ->e ->f ->g )->Bundle v a ->Bundle v b ->Bundle v c ->Bundle v d ->Bundle v e ->Bundle v f ->Bundle v g {-# INLINEzipWith6 #-}zipWith6 :: forall a b c d e f g (v :: * -> *).
(a -> b -> c -> d -> e -> f -> g)
-> Bundle v a
-> Bundle v b
-> Bundle v c
-> Bundle v d
-> Bundle v e
-> Bundle v f
-> Bundle v g
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
M.zipWith6 zip ::Bundle v a ->Bundle v b ->Bundle v (a ,b ){-# INLINEzip #-}zip :: forall (v :: * -> *) a b.
Bundle v a -> Bundle v b -> Bundle v (a, b)
zip =forall (m :: * -> *) (v :: * -> *) a b.
Monad m =>
Bundle m v a -> Bundle m v b -> Bundle m v (a, b)
M.zip zip3 ::Bundle v a ->Bundle v b ->Bundle v c ->Bundle v (a ,b ,c ){-# INLINEzip3 #-}zip3 :: forall (v :: * -> *) a b c.
Bundle v a -> Bundle v b -> Bundle v c -> Bundle v (a, b, c)
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)
M.zip3 zip4 ::Bundle v a ->Bundle v b ->Bundle v c ->Bundle v d ->Bundle v (a ,b ,c ,d ){-# INLINEzip4 #-}zip4 :: forall (v :: * -> *) a b c d.
Bundle v a
-> Bundle v b -> Bundle v c -> Bundle v d -> Bundle v (a, b, c, d)
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)
M.zip4 zip5 ::Bundle v a ->Bundle v b ->Bundle v c ->Bundle v d ->Bundle v e ->Bundle v (a ,b ,c ,d ,e ){-# INLINEzip5 #-}zip5 :: forall (v :: * -> *) a b c d e.
Bundle v a
-> Bundle v b
-> Bundle v c
-> Bundle v d
-> Bundle v e
-> Bundle v (a, b, c, d, e)
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)
M.zip5 zip6 ::Bundle v a ->Bundle v b ->Bundle v c ->Bundle v d ->Bundle v e ->Bundle v f ->Bundle v (a ,b ,c ,d ,e ,f ){-# INLINEzip6 #-}zip6 :: forall (v :: * -> *) a b c d e f.
Bundle v a
-> Bundle v b
-> Bundle v c
-> Bundle v d
-> Bundle v e
-> Bundle v f
-> Bundle v (a, b, c, d, e, f)
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)
M.zip6 -- Filtering-- ----------- | Drop elements which do not satisfy the predicatefilter ::(a ->Bool)->Bundle v a ->Bundle v a {-# INLINEfilter #-}filter :: forall a (v :: * -> *). (a -> Bool) -> Bundle v a -> Bundle v a
filter =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> Bool) -> Bundle m v a -> Bundle m v a
M.filter -- | Longest prefix of elements that satisfy the predicatetakeWhile ::(a ->Bool)->Bundle v a ->Bundle v a {-# INLINEtakeWhile #-}takeWhile :: forall a (v :: * -> *). (a -> Bool) -> Bundle v a -> Bundle v a
takeWhile =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> Bool) -> Bundle m v a -> Bundle m v a
M.takeWhile -- | Drop the longest prefix of elements that satisfy the predicatedropWhile ::(a ->Bool)->Bundle v a ->Bundle v a {-# INLINEdropWhile #-}dropWhile :: forall a (v :: * -> *). (a -> Bool) -> Bundle v a -> Bundle v a
dropWhile =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> Bool) -> Bundle m v a -> Bundle m v a
M.dropWhile -- Searching-- ---------infix4`elem` -- | Check whether the 'Bundle' contains an elementelem ::Eqa =>a ->Bundle v a ->Bool{-# INLINEelem #-}elem :: forall a (v :: * -> *). Eq a => a -> Bundle v a -> Bool
elem a
x =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) a (v :: * -> *).
(Monad m, Eq a) =>
a -> Bundle m v a -> m Bool
M.elem a
x infix4`notElem` -- | Inverse of `elem`notElem ::Eqa =>a ->Bundle v a ->Bool{-# INLINEnotElem #-}notElem :: forall a (v :: * -> *). Eq a => a -> Bundle v a -> Bool
notElem a
x =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) a (v :: * -> *).
(Monad m, Eq a) =>
a -> Bundle m v a -> m Bool
M.notElem a
x -- | Yield 'Just' the first element matching the predicate or 'Nothing' if no-- such element exists.find ::(a ->Bool)->Bundle v a ->Maybea {-# INLINEfind #-}find :: forall a (v :: * -> *). (a -> Bool) -> Bundle v a -> Maybe a
find a -> Bool
f =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> Bool) -> Bundle m v a -> m (Maybe a)
M.find a -> Bool
f -- | Yield 'Just' the index of the first element matching the predicate or-- 'Nothing' if no such element exists.findIndex ::(a ->Bool)->Bundle v a ->MaybeInt{-# INLINEfindIndex #-}findIndex :: forall a (v :: * -> *). (a -> Bool) -> Bundle v a -> Maybe Int
findIndex a -> Bool
f =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> Bool) -> Bundle m v a -> m (Maybe Int)
M.findIndex a -> Bool
f -- Folding-- --------- | Left foldfoldl ::(a ->b ->a )->a ->Bundle v b ->a {-# INLINEfoldl #-}foldl :: forall a b (v :: * -> *). (a -> b -> a) -> a -> Bundle v b -> a
foldl a -> b -> a
f a
z =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> m a
M.foldl a -> b -> a
f a
z -- | Left fold on non-empty 'Bundle'sfoldl1 ::(a ->a ->a )->Bundle v a ->a {-# INLINEfoldl1 #-}foldl1 :: forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
foldl1 a -> a -> a
f =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> a) -> Bundle m v a -> m a
M.foldl1 a -> a -> a
f -- | Left fold with strict accumulatorfoldl' ::(a ->b ->a )->a ->Bundle v b ->a {-# INLINEfoldl' #-}foldl' :: forall a b (v :: * -> *). (a -> b -> a) -> a -> Bundle v b -> a
foldl' a -> b -> a
f a
z =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> m a
M.foldl' a -> b -> a
f a
z -- | Left fold on non-empty 'Bundle's with strict accumulatorfoldl1' ::(a ->a ->a )->Bundle v a ->a {-# INLINEfoldl1' #-}foldl1' :: forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
foldl1' a -> a -> a
f =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> a) -> Bundle m v a -> m a
M.foldl1' a -> a -> a
f -- | Right foldfoldr ::(a ->b ->b )->b ->Bundle v a ->b {-# INLINEfoldr #-}foldr :: forall a b (v :: * -> *). (a -> b -> b) -> b -> Bundle v a -> b
foldr a -> b -> b
f b
z =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> b) -> b -> Bundle m v a -> m b
M.foldr a -> b -> b
f b
z -- | Right fold on non-empty 'Bundle'sfoldr1 ::(a ->a ->a )->Bundle v a ->a {-# INLINEfoldr1 #-}foldr1 :: forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> a
foldr1 a -> a -> a
f =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> a) -> Bundle m v a -> m a
M.foldr1 a -> a -> a
f -- Specialised folds-- -----------------and ::Bundle v Bool->Bool{-# INLINEand #-}and :: forall (v :: * -> *). Bundle v Bool -> Bool
and =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *).
Monad m =>
Bundle m v Bool -> m Bool
M.and or ::Bundle v Bool->Bool{-# INLINEor #-}or :: forall (v :: * -> *). Bundle v Bool -> Bool
or =forall a. Id a -> a
unId forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *).
Monad m =>
Bundle m v Bool -> m Bool
M.or -- Unfolding-- ----------- | Unfoldunfoldr ::(s ->Maybe(a ,s ))->s ->Bundle v a {-# INLINEunfoldr #-}unfoldr :: forall s a (v :: * -> *). (s -> Maybe (a, s)) -> s -> Bundle v a
unfoldr =forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
(s -> Maybe (a, s)) -> s -> Bundle m u a
M.unfoldr -- | Unfold at most @n@ elementsunfoldrN ::Int->(s ->Maybe(a ,s ))->s ->Bundle v a {-# INLINEunfoldrN #-}unfoldrN :: forall s a (v :: * -> *).
Int -> (s -> Maybe (a, s)) -> s -> Bundle v a
unfoldrN =forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
Int -> (s -> Maybe (a, s)) -> s -> Bundle m u a
M.unfoldrN -- | Unfold exactly @n@ elements---- @since 0.12.2.0unfoldrExactN ::Int->(s ->(a ,s ))->s ->Bundle v a {-# INLINEunfoldrExactN #-}unfoldrExactN :: forall s a (v :: * -> *). Int -> (s -> (a, s)) -> s -> Bundle v a
unfoldrExactN =forall (m :: * -> *) s a (u :: * -> *).
Monad m =>
Int -> (s -> (a, s)) -> s -> Bundle m u a
M.unfoldrExactN -- | /O(n)/ Apply function \(\max(n - 1, 0)\) times to an initial value, producing a pure-- bundle of exact length \(\max(n, 0)\). Zeroth element will contain the initial value.iterateN ::Int->(a ->a )->a ->Bundle v a {-# INLINEiterateN #-}iterateN :: forall a (v :: * -> *). Int -> (a -> a) -> a -> Bundle v a
iterateN =forall (m :: * -> *) a (u :: * -> *).
Monad m =>
Int -> (a -> a) -> a -> Bundle m u a
M.iterateN -- Scans-- ------- | Prefix scanprescanl ::(a ->b ->a )->a ->Bundle v b ->Bundle v a {-# INLINEprescanl #-}prescanl :: forall a b (v :: * -> *).
(a -> b -> a) -> a -> Bundle v b -> Bundle v a
prescanl =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
M.prescanl -- | Prefix scan with strict accumulatorprescanl' ::(a ->b ->a )->a ->Bundle v b ->Bundle v a {-# INLINEprescanl' #-}prescanl' :: forall a b (v :: * -> *).
(a -> b -> a) -> a -> Bundle v b -> Bundle v a
prescanl' =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
M.prescanl' -- | Suffix scanpostscanl ::(a ->b ->a )->a ->Bundle v b ->Bundle v a {-# INLINEpostscanl #-}postscanl :: forall a b (v :: * -> *).
(a -> b -> a) -> a -> Bundle v b -> Bundle v a
postscanl =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
M.postscanl -- | Suffix scan with strict accumulatorpostscanl' ::(a ->b ->a )->a ->Bundle v b ->Bundle v a {-# INLINEpostscanl' #-}postscanl' :: forall a b (v :: * -> *).
(a -> b -> a) -> a -> Bundle v b -> Bundle v a
postscanl' =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
M.postscanl' -- | Haskell-style scanscanl ::(a ->b ->a )->a ->Bundle v b ->Bundle v a {-# INLINEscanl #-}scanl :: forall a b (v :: * -> *).
(a -> b -> a) -> a -> Bundle v b -> Bundle v a
scanl =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
M.scanl -- | Haskell-style scan with strict accumulatorscanl' ::(a ->b ->a )->a ->Bundle v b ->Bundle v a {-# INLINEscanl' #-}scanl' :: forall a b (v :: * -> *).
(a -> b -> a) -> a -> Bundle v b -> Bundle v a
scanl' =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> a) -> a -> Bundle m v b -> Bundle m v a
M.scanl' -- | Initial-value free scan over a 'Bundle'scanl1 ::(a ->a ->a )->Bundle v a ->Bundle v a {-# INLINEscanl1 #-}scanl1 :: forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> Bundle v a
scanl1 =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> a) -> Bundle m v a -> Bundle m v a
M.scanl1 -- | Initial-value free scan over a 'Bundle' with a strict accumulatorscanl1' ::(a ->a ->a )->Bundle v a ->Bundle v a {-# INLINEscanl1' #-}scanl1' :: forall a (v :: * -> *). (a -> a -> a) -> Bundle v a -> Bundle v a
scanl1' =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> a) -> Bundle m v a -> Bundle m v a
M.scanl1' -- Comparisons-- ------------- | Check if two 'Bundle's are equaleq ::(Eqa )=>Bundle v a ->Bundle v a ->Bool{-# INLINEeq #-}eq :: forall a (v :: * -> *). Eq a => Bundle v a -> Bundle v a -> Bool
eq =forall a b (v :: * -> *).
(a -> b -> Bool) -> Bundle v a -> Bundle v b -> Bool
eqBy forall a. Eq a => a -> a -> Bool
(==)eqBy ::(a ->b ->Bool)->Bundle v a ->Bundle v b ->Bool{-# INLINEeqBy #-}eqBy :: forall a b (v :: * -> *).
(a -> b -> Bool) -> Bundle v a -> Bundle v b -> Bool
eqBy a -> b -> Bool
e Bundle v a
x Bundle v b
y =forall a. Id a -> a
unId (forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> Bool) -> Bundle m v a -> Bundle m v b -> m Bool
M.eqBy a -> b -> Bool
e Bundle v a
x Bundle v b
y )-- | Lexicographically compare two 'Bundle'scmp ::(Orda )=>Bundle v a ->Bundle v a ->Ordering{-# INLINEcmp #-}cmp :: forall a (v :: * -> *).
Ord a =>
Bundle v a -> Bundle v a -> Ordering
cmp =forall a b (v :: * -> *).
(a -> b -> Ordering) -> Bundle v a -> Bundle v b -> Ordering
cmpBy forall a. Ord a => a -> a -> Ordering
comparecmpBy ::(a ->b ->Ordering)->Bundle v a ->Bundle v b ->Ordering{-# INLINEcmpBy #-}cmpBy :: forall a b (v :: * -> *).
(a -> b -> Ordering) -> Bundle v a -> Bundle v b -> Ordering
cmpBy a -> b -> Ordering
c Bundle v a
x Bundle v b
y =forall a. Id a -> a
unId (forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> Ordering) -> Bundle m v a -> Bundle m v b -> m Ordering
M.cmpBy a -> b -> Ordering
c Bundle v a
x Bundle v b
y )instanceEqa =>Eq(M.Bundle Id v a )where{-# INLINE(==)#-}== :: Bundle Id v a -> Bundle Id v a -> Bool
(==)=forall a (v :: * -> *). Eq a => Bundle v a -> Bundle v a -> Bool
eq instanceOrda =>Ord(M.Bundle Id v a )where{-# INLINEcompare#-}compare :: Bundle Id v a -> Bundle Id v a -> Ordering
compare =forall a (v :: * -> *).
Ord a =>
Bundle v a -> Bundle v a -> Ordering
cmp instanceEq1(M.Bundle Id v )where{-# INLINEliftEq#-}liftEq :: forall a b.
(a -> b -> Bool) -> Bundle Id v a -> Bundle Id v b -> Bool
liftEq =forall a b (v :: * -> *).
(a -> b -> Bool) -> Bundle v a -> Bundle v b -> Bool
eqBy instanceOrd1(M.Bundle Id v )where{-# INLINEliftCompare#-}liftCompare :: forall a b.
(a -> b -> Ordering) -> Bundle Id v a -> Bundle Id v b -> Ordering
liftCompare =forall a b (v :: * -> *).
(a -> b -> Ordering) -> Bundle v a -> Bundle v b -> Ordering
cmpBy -- Monadic combinators-- --------------------- | Apply a monadic action to each element of the stream, producing a monadic-- stream of resultsmapM ::Monadm =>(a ->m b )->Bundle v a ->M.Bundle m v b {-# INLINEmapM #-}mapM :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> m b) -> Bundle v a -> Bundle m v b
mapM a -> m b
f =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> m b) -> Bundle m v a -> Bundle m v b
M.mapM a -> m b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift -- | Apply a monadic action to each element of the streammapM_ ::Monadm =>(a ->m b )->Bundle v a ->m (){-# INLINEmapM_ #-}mapM_ :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> m b) -> Bundle v a -> m ()
mapM_ a -> m b
f =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> m b) -> Bundle m v a -> m ()
M.mapM_ a -> m b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift zipWithM ::Monadm =>(a ->b ->m c )->Bundle v a ->Bundle v b ->M.Bundle m v c {-# INLINEzipWithM #-}zipWithM :: forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> m c) -> Bundle v a -> Bundle v b -> Bundle m v c
zipWithM a -> b -> m c
f Bundle v a
as Bundle v b
bs =forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> m c) -> Bundle m v a -> Bundle m v b -> Bundle m v c
M.zipWithM a -> b -> m c
f (forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift Bundle v a
as )(forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift Bundle v b
bs )zipWithM_ ::Monadm =>(a ->b ->m c )->Bundle v a ->Bundle v b ->m (){-# INLINEzipWithM_ #-}zipWithM_ :: forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> m c) -> Bundle v a -> Bundle v b -> m ()
zipWithM_ a -> b -> m c
f Bundle v a
as Bundle v b
bs =forall (m :: * -> *) a b c (v :: * -> *).
Monad m =>
(a -> b -> m c) -> Bundle m v a -> Bundle m v b -> m ()
M.zipWithM_ a -> b -> m c
f (forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift Bundle v a
as )(forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift Bundle v b
bs )-- | Yield a monadic stream of elements that satisfy the monadic predicatefilterM ::Monadm =>(a ->m Bool)->Bundle v a ->M.Bundle m v a {-# INLINEfilterM #-}filterM :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle v a -> Bundle m v a
filterM a -> m Bool
f =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> m Bool) -> Bundle m v a -> Bundle m v a
M.filterM a -> m Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift -- | /O(n)/ Apply monadic function to each element of a bundle and-- discard elements returning Nothing.---- @since 0.12.2.0mapMaybeM ::Monadm =>(a ->m (Maybeb ))->Bundle v a ->M.Bundle m v b {-# INLINEmapMaybeM #-}mapMaybeM :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> m (Maybe b)) -> Bundle v a -> Bundle m v b
mapMaybeM a -> m (Maybe b)
f =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> m (Maybe b)) -> Bundle m v a -> Bundle m v b
M.mapMaybeM a -> m (Maybe b)
f forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift -- | Monadic foldfoldM ::Monadm =>(a ->b ->m a )->a ->Bundle v b ->m a {-# INLINEfoldM #-}foldM :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle v b -> m a
foldM a -> b -> m a
m a
z =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> m a
M.foldM a -> b -> m a
m a
z forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift -- | Monadic fold over non-empty streamfold1M ::Monadm =>(a ->a ->m a )->Bundle v a ->m a {-# INLINEfold1M #-}fold1M :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle v a -> m a
fold1M a -> a -> m a
m =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
M.fold1M a -> a -> m a
m forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift -- | Monadic fold with strict accumulatorfoldM' ::Monadm =>(a ->b ->m a )->a ->Bundle v b ->m a {-# INLINEfoldM' #-}foldM' :: forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle v b -> m a
foldM' a -> b -> m a
m a
z =forall (m :: * -> *) a b (v :: * -> *).
Monad m =>
(a -> b -> m a) -> a -> Bundle m v b -> m a
M.foldM' a -> b -> m a
m a
z forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift -- | Monad fold over non-empty stream with strict accumulatorfold1M' ::Monadm =>(a ->a ->m a )->Bundle v a ->m a {-# INLINEfold1M' #-}fold1M' :: forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle v a -> m a
fold1M' a -> a -> m a
m =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
(a -> a -> m a) -> Bundle m v a -> m a
M.fold1M' a -> a -> m a
m forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift -- Enumerations-- -------------- | Yield a 'Bundle' of the given length containing the values @x@, @x+y@,-- @x+y+y@ etc.enumFromStepN ::Numa =>a ->a ->Int->Bundle v a {-# INLINEenumFromStepN #-}enumFromStepN :: forall a (v :: * -> *). Num a => a -> a -> Int -> Bundle v a
enumFromStepN =forall a (m :: * -> *) (v :: * -> *).
(Num a, Monad m) =>
a -> a -> Int -> Bundle m v a
M.enumFromStepN -- | Enumerate values---- /WARNING:/ This operations can be very inefficient. If at all possible, use-- 'enumFromStepN' instead.enumFromTo ::Enuma =>a ->a ->Bundle v a {-# INLINEenumFromTo #-}enumFromTo :: forall a (v :: * -> *). Enum a => a -> a -> Bundle v a
enumFromTo =forall a (m :: * -> *) (v :: * -> *).
(Enum a, Monad m) =>
a -> a -> Bundle m v a
M.enumFromTo -- | Enumerate values with a given step.---- /WARNING:/ This operations is very inefficient. If at all possible, use-- 'enumFromStepN' instead.enumFromThenTo ::Enuma =>a ->a ->a ->Bundle v a {-# INLINEenumFromThenTo #-}enumFromThenTo :: forall a (v :: * -> *). Enum a => a -> a -> a -> Bundle v a
enumFromThenTo =forall a (m :: * -> *) (v :: * -> *).
(Enum a, Monad m) =>
a -> a -> a -> Bundle m v a
M.enumFromThenTo -- Conversions-- ------------- | Convert a 'Bundle' to a listtoList ::Bundle v a ->[a ]{-# INLINEtoList #-}-- toList s = unId (M.toList s)toList :: forall (v :: * -> *) a. Bundle v a -> [a]
toList Bundle v a
s =forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build(\a -> b -> b
c b
n ->forall a b (v :: * -> *). (a -> b -> b) -> b -> Bundle v a -> b
toListFB a -> b -> b
c b
n Bundle v a
s )-- This supports foldr/build list fusion that GHC implementstoListFB ::(a ->b ->b )->b ->Bundle v a ->b {-# INLINE[0]toListFB #-}toListFB :: forall a b (v :: * -> *). (a -> b -> b) -> b -> Bundle v a -> b
toListFB a -> b -> b
c b
n M.Bundle {sElems :: forall (m :: * -> *) (v :: * -> *) a. Bundle m v a -> Stream m a
M.sElems =Streams -> Id (Step s a)
step s
t }=s -> b
go s
t wherego :: s -> b
go s
s =caseforall a. Id a -> a
unId (s -> Id (Step s a)
step s
s )ofYielda
x s
s' ->a
x a -> b -> b
`c` s -> b
go s
s' Skips
s' ->s -> b
go s
s' Step s a
Done->b
n -- | Create a 'Bundle' from a listfromList ::[a ]->Bundle v a {-# INLINEfromList #-}fromList :: forall a (v :: * -> *). [a] -> Bundle v a
fromList =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
[a] -> Bundle m v a
M.fromList -- | Create a 'Bundle' from the first @n@ elements of a list---- > fromListN n xs = fromList (take n xs)fromListN ::Int->[a ]->Bundle v a {-# INLINEfromListN #-}fromListN :: forall a (v :: * -> *). Int -> [a] -> Bundle v a
fromListN =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Int -> [a] -> Bundle m v a
M.fromListN unsafeFromList ::Size ->[a ]->Bundle v a {-# INLINEunsafeFromList #-}unsafeFromList :: forall a (v :: * -> *). Size -> [a] -> Bundle v a
unsafeFromList =forall (m :: * -> *) a (v :: * -> *).
Monad m =>
Size -> [a] -> Bundle m v a
M.unsafeFromList fromVector ::Vector v a =>v a ->Bundle v a {-# INLINEfromVector #-}fromVector :: forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
fromVector =forall (m :: * -> *) (v :: * -> *) a.
(Monad m, Vector v a) =>
v a -> Bundle m v a
M.fromVector reVector ::Bundle u a ->Bundle v a {-# INLINEreVector #-}reVector :: forall (u :: * -> *) a (v :: * -> *). Bundle u a -> Bundle v a
reVector =forall (m :: * -> *) (u :: * -> *) a (v :: * -> *).
Monad m =>
Bundle m u a -> Bundle m v a
M.reVector fromVectors ::Vector v a =>[v a ]->Bundle v a {-# INLINEfromVectors #-}fromVectors :: forall (v :: * -> *) a. Vector v a => [v a] -> Bundle v a
fromVectors =forall (m :: * -> *) (v :: * -> *) a.
(Monad m, Vector v a) =>
[v a] -> Bundle m v a
M.fromVectors concatVectors ::Vector v a =>Bundle u (v a )->Bundle v a {-# INLINEconcatVectors #-}concatVectors :: forall (v :: * -> *) a (u :: * -> *).
Vector v a =>
Bundle u (v a) -> Bundle v a
concatVectors =forall (m :: * -> *) (v :: * -> *) a (u :: * -> *).
(Monad m, Vector v a) =>
Bundle m u (v a) -> Bundle m v a
M.concatVectors -- | Create a 'Bundle' of values from a 'Bundle' of streamable thingsflatten ::(a ->s )->(s ->Steps b )->Size ->Bundle v a ->Bundle v b {-# INLINE_FUSED flatten #-}flatten :: forall a s b (v :: * -> *).
(a -> s) -> (s -> Step s b) -> Size -> Bundle v a -> Bundle v b
flatten a -> s
mk s -> Step s b
istep Size
sz =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
M.flatten (forall (m :: * -> *) a. Monad m => a -> m a
returnforall b c a. (b -> c) -> (a -> b) -> a -> c
.a -> s
mk )(forall (m :: * -> *) a. Monad m => a -> m a
returnforall b c a. (b -> c) -> (a -> b) -> a -> c
.s -> Step s b
istep )Size
sz forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall (m :: * -> *) (v :: * -> *) a.
Monad m =>
Bundle Id v a -> Bundle m v a
lift