author Roman Leshchinskiy Sat, 28 Jan 2012 09:28:14 +0000 (09:28 +0000) committer Roman Leshchinskiy Sat, 28 Jan 2012 09:28:14 +0000 (09:28 +0000)

index c065e58..64e64c7 100644 (file)
@@ -484,7 +484,8 @@ scanl1' = M.scanl1'
-- | Check if two 'Stream's are equal
eq :: Eq a => Stream v a -> Stream v a -> Bool
{-# INLINE_STREAM eq #-}
-- | Check if two 'Stream's are equal
eq :: Eq a => Stream v a -> Stream v a -> Bool
{-# INLINE_STREAM eq #-}
-eq (M.Stream (M.Unf step1 s1) _ _) (M.Stream (M.Unf step2 s2) _ _) = eq_loop0 SPEC s1 s2
+eq M.Stream{M.sElems = M.Unf step1 s1}
+   M.Stream{M.sElems = M.Unf step2 s2} = eq_loop0 SPEC s1 s2
where
eq_loop0 !sPEC s1 s2 = case unId (step1 s1) of
Yield x s1' -> eq_loop1 SPEC x s1' s2
where
eq_loop0 !sPEC s1 s2 = case unId (step1 s1) of
Yield x s1' -> eq_loop1 SPEC x s1' s2
@@ -499,7 +500,8 @@ eq (M.Stream (M.Unf step1 s1) _ _) (M.Stream (M.Unf step2 s2) _ _) = eq_loop0 SP
-- | Lexicographically compare two 'Stream's
cmp :: Ord a => Stream v a -> Stream v a -> Ordering
{-# INLINE_STREAM cmp #-}
-- | Lexicographically compare two 'Stream's
cmp :: Ord a => Stream v a -> Stream v a -> Ordering
{-# INLINE_STREAM cmp #-}
-cmp (M.Stream (M.Unf step1 s1) _ _) (M.Stream (M.Unf step2 s2) _ _) = cmp_loop0 SPEC s1 s2
+cmp M.Stream{M.sElems = M.Unf step1 s1}
+    M.Stream{M.sElems = M.Unf step2 s2} = cmp_loop0 SPEC s1 s2
where
cmp_loop0 !sPEC s1 s2 = case unId (step1 s1) of
Yield x s1' -> cmp_loop1 SPEC x s1' s2
where
cmp_loop0 !sPEC s1 s2 = case unId (step1 s1) of
Yield x s1' -> cmp_loop1 SPEC x s1' s2
@@ -606,7 +608,7 @@ toList s = build (\c n -> toListFB c n s)
-- This supports foldr/build list fusion that GHC implements
toListFB :: (a -> b -> b) -> b -> Stream v a -> b
{-# INLINE  toListFB #-}
-- This supports foldr/build list fusion that GHC implements
toListFB :: (a -> b -> b) -> b -> Stream v a -> b
{-# INLINE  toListFB #-}
-toListFB c n (M.Stream (M.Unf step s) _ _) = go s
+toListFB c n M.Stream{M.sElems = M.Unf step s} = go s
where
go s = case unId (step s) of
Yield x s' -> x `c` go s'
where
go s = case unId (step s) of
Yield x s' -> x `c` go s'
index cf53069..e8a1262 100644 (file)
@@ -162,7 +162,10 @@ instance Monad m => Functor (Unf m) where
step' s = do r <- step s ; return (fmap f r)

step' s = do r <- step s ; return (fmap f r)

-data Stream m v a = Stream (Unf m a) (Unf m (Chunk v a)) Size
+data Stream m v a = Stream { sElems  :: Unf m a
+                           , sChunks :: Unf m (Chunk v a)
+                           , sSize   :: Size
+                           }

simple :: Monad m => (s -> m (Step s a)) -> s -> Size -> Stream m v a
{-# INLINE simple #-}

simple :: Monad m => (s -> m (Step s a)) -> s -> Size -> Stream m v a
{-# INLINE simple #-}
@@ -174,12 +177,12 @@ simple step s sz = Stream (Unf step s) (Unf step' s) sz
-- | 'Size' hint of a 'Stream'
size :: Stream m v a -> Size
{-# INLINE size #-}
-- | 'Size' hint of a 'Stream'
size :: Stream m v a -> Size
{-# INLINE size #-}
-size (Stream _ _ sz) = sz
+size = sSize

-- | Attach a 'Size' hint to a 'Stream'
sized :: Stream m v a -> Size -> Stream m v a
{-# INLINE_STREAM sized #-}

-- | Attach a 'Size' hint to a 'Stream'
sized :: Stream m v a -> Size -> Stream m v a
{-# INLINE_STREAM sized #-}
-sized (Stream p q _) sz = Stream p q sz
+sized s sz = s { sSize = sz }

-- Length
-- ------

-- Length
-- ------
@@ -308,7 +311,7 @@ Stream (Unf stepa sa) (Unf vstepa vsa) na
-- | First element of the 'Stream' or error if empty
head :: Monad m => Stream m v a -> m a
-- | First element of the 'Stream' or error if empty
head :: Monad m => Stream m v a -> m a
where
= do
where
= do
@@ -323,7 +326,7 @@ head (Stream (Unf step s) _ _) = head_loop SPEC s
-- | Last element of the 'Stream' or error if empty
last :: Monad m => Stream m v a -> m a
{-# INLINE_STREAM last #-}
-- | Last element of the 'Stream' or error if empty
last :: Monad m => Stream m v a -> m a
{-# INLINE_STREAM last #-}
-last (Stream (Unf step s) _ _) = last_loop0 SPEC s
+last Stream{sElems = Unf step s} = last_loop0 SPEC s
where
last_loop0 !sPEC s
= do
where
last_loop0 !sPEC s
= do
@@ -345,8 +348,8 @@ infixl 9 !!
-- | Element at the given position
(!!) :: Monad m => Stream m v a -> Int -> m a
{-# INLINE (!!) #-}
-- | Element at the given position
(!!) :: Monad m => Stream m v a -> Int -> m a
{-# INLINE (!!) #-}
-Stream (Unf step s) _ _ !! i | i < 0     = ERROR "!!" "negative index"
-                             | otherwise = index_loop SPEC s i
+Stream{sElems = Unf step s} !! i | i < 0     = ERROR "!!" "negative index"
+                                 | otherwise = index_loop SPEC s i
where
index_loop !sPEC s i
= i `seq`
where
index_loop !sPEC s i
= i `seq`
@@ -362,7 +365,7 @@ infixl 9 !?
-- | Element at the given position or 'Nothing' if out of bounds
(!?) :: Monad m => Stream m v a -> Int -> m (Maybe a)
{-# INLINE (!?) #-}
-- | Element at the given position or 'Nothing' if out of bounds
(!?) :: Monad m => Stream m v a -> Int -> m (Maybe a)
{-# INLINE (!?) #-}
-Stream (Unf step s) _ _ !? i = index_loop SPEC s i
+Stream{sElems = Unf step s} !? i = index_loop SPEC s i
where
index_loop !sPEC s i
= i `seq`
where
index_loop !sPEC s i
= i `seq`
@@ -388,7 +391,7 @@ slice i n s = take n (drop i s)
-- | All but the last element
init :: Monad m => Stream m v a -> Stream m v a
{-# INLINE_STREAM init #-}
-- | All but the last element
init :: Monad m => Stream m v a -> Stream m v a
{-# INLINE_STREAM init #-}
-init (Stream (Unf step s) _ sz) = simple step' (Nothing, s) (sz - 1)
+init Stream{sElems = Unf step s, sSize = sz} = simple step' (Nothing, s) (sz - 1)
where
{-# INLINE_INNER step' #-}
step' (Nothing, s) = liftM (\r ->
where
{-# INLINE_INNER step' #-}
step' (Nothing, s) = liftM (\r ->
@@ -408,7 +411,7 @@ init (Stream (Unf step s) _ sz) = simple step' (Nothing, s) (sz - 1)
-- | All but the first element
tail :: Monad m => Stream m v a -> Stream m v a
{-# INLINE_STREAM tail #-}
-- | All but the first element
tail :: Monad m => Stream m v a -> Stream m v a
{-# INLINE_STREAM tail #-}
-tail (Stream (Unf step s) _ sz) = simple step' (Left s) (sz - 1)
+tail Stream{sElems = Unf step s, sSize = sz} = simple step' (Left s) (sz - 1)
where
{-# INLINE_INNER step' #-}
step' (Left  s) = liftM (\r ->
where
{-# INLINE_INNER step' #-}
step' (Left  s) = liftM (\r ->
@@ -428,7 +431,8 @@ tail (Stream (Unf step s) _ sz) = simple step' (Left s) (sz - 1)
-- | The first @n@ elements
take :: Monad m => Int -> Stream m v a -> Stream m v a
{-# INLINE_STREAM take #-}
-- | The first @n@ elements
take :: Monad m => Int -> Stream m v a -> Stream m v a
{-# INLINE_STREAM take #-}
-take n (Stream (Unf step s) _ sz) = simple step' (s, 0) (smaller (Exact n) sz)
+take n Stream{sElems = Unf step s, sSize = sz}
+  = simple step' (s, 0) (smaller (Exact n) sz)
where
{-# INLINE_INNER step' #-}
step' (s, i) | i < n = liftM (\r ->
where
{-# INLINE_INNER step' #-}
step' (s, i) | i < n = liftM (\r ->
@@ -442,7 +446,8 @@ take n (Stream (Unf step s) _ sz) = simple step' (s, 0) (smaller (Exact n) sz)
-- | All but the first @n@ elements
drop :: Monad m => Int -> Stream m v a -> Stream m v a
{-# INLINE_STREAM drop #-}
-- | All but the first @n@ elements
drop :: Monad m => Int -> Stream m v a -> Stream m v a
{-# INLINE_STREAM drop #-}
-drop n (Stream (Unf step s) _ sz) = simple step' (s, Just n) (sz - Exact n)
+drop n Stream{sElems = Unf step s, sSize = sz}
+  = simple step' (s, Just n) (sz - Exact n)
where
{-# INLINE_INNER step' #-}
step' (s, Just i) | i > 0 = liftM (\r ->
where
{-# INLINE_INNER step' #-}
step' (s, Just i) | i > 0 = liftM (\r ->
@@ -476,7 +481,7 @@ map f = mapM (return . f)
-- | Map a monadic function over a 'Stream'
mapM :: Monad m => (a -> m b) -> Stream m v a -> Stream m v b
{-# INLINE_STREAM mapM #-}
-- | Map a monadic function over a 'Stream'
mapM :: Monad m => (a -> m b) -> Stream m v a -> Stream m v b
{-# INLINE_STREAM mapM #-}
-mapM f (Stream (Unf step s) _ n) = simple step' s n
+mapM f Stream{sElems = Unf step s, sSize = n} = simple step' s n
where
{-# INLINE_INNER step' #-}
step' s = do
where
{-# INLINE_INNER step' #-}
step' s = do
@@ -488,7 +493,7 @@ mapM f (Stream (Unf step s) _ n) = simple step' s n

consume :: Monad m => Stream m v a -> m ()
{-# INLINE_STREAM consume #-}

consume :: Monad m => Stream m v a -> m ()
{-# INLINE_STREAM consume #-}
-consume (Stream _ (Unf step s) _) = consume_loop SPEC s
+consume Stream {sChunks = Unf step s} = consume_loop SPEC s
where
consume_loop !sPEC s
= do
where
consume_loop !sPEC s
= do
@@ -507,11 +512,11 @@ mapM_ m = consume . mapM m
trans :: (Monad m, Monad m') => (forall a. m a -> m' a)
-> Stream m v a -> Stream m' v a
{-# INLINE_STREAM trans #-}
trans :: (Monad m, Monad m') => (forall a. m a -> m' a)
-> Stream m v a -> Stream m' v a
{-# INLINE_STREAM trans #-}
-trans f (Stream (Unf step s) _ n) = simple (f . step) s n
+trans f Stream{sElems = Unf step s, sSize = n} = simple (f . step) s n

unbox :: Monad m => Stream m v (Box a) -> Stream m v a
{-# INLINE_STREAM unbox #-}

unbox :: Monad m => Stream m v (Box a) -> Stream m v a
{-# INLINE_STREAM unbox #-}
-unbox (Stream (Unf step s) _ n) = simple step' s n
+unbox Stream{sElems = Unf step s, sSize = n} = simple step' s n
where
{-# INLINE_INNER step' #-}
step' s = do
where
{-# INLINE_INNER step' #-}
step' s = do
@@ -527,7 +532,7 @@ unbox (Stream (Unf step s) _ n) = simple step' s n
-- | Pair each element in a 'Stream' with its index
indexed :: Monad m => Stream m v a -> Stream m v (Int,a)
{-# INLINE_STREAM indexed #-}
-- | Pair each element in a 'Stream' with its index
indexed :: Monad m => Stream m v a -> Stream m v (Int,a)
{-# INLINE_STREAM indexed #-}
-indexed (Stream (Unf step s) _ n) = simple step' (s,0) n
+indexed Stream{sElems = Unf step s, sSize = n} = simple step' (s,0) n
where
{-# INLINE_INNER step' #-}
step' (s,i) = i `seq`
where
{-# INLINE_INNER step' #-}
step' (s,i) = i `seq`
@@ -542,7 +547,7 @@ indexed (Stream (Unf step s) _ n) = simple step' (s,0) n
-- and counting down
indexedR :: Monad m => Int -> Stream m v a -> Stream m v (Int,a)
{-# INLINE_STREAM indexedR #-}
-- and counting down
indexedR :: Monad m => Int -> Stream m v a -> Stream m v (Int,a)
{-# INLINE_STREAM indexedR #-}
-indexedR m (Stream (Unf step s) _ n) = simple step' (s,m) n
+indexedR m Stream{sElems = Unf step s, sSize = n} = simple step' (s,m) n
where
{-# INLINE_INNER step' #-}
step' (s,i) = i `seq`
where
{-# INLINE_INNER step' #-}
step' (s,i) = i `seq`
@@ -558,7 +563,8 @@ indexedR m (Stream (Unf step s) _ n) = simple step' (s,m) n
-- | Zip two 'Stream's with the given monadic function
zipWithM :: Monad m => (a -> b -> m c) -> Stream m v a -> Stream m v b -> Stream m v c
{-# INLINE_STREAM zipWithM #-}
-- | Zip two 'Stream's with the given monadic function
zipWithM :: Monad m => (a -> b -> m c) -> Stream m v a -> Stream m v b -> Stream m v c
{-# INLINE_STREAM zipWithM #-}
-zipWithM f (Stream (Unf stepa sa) _ na) (Stream (Unf stepb sb) _ nb)
+zipWithM f Stream{sElems = Unf stepa sa, sSize = na}
+           Stream{sElems = Unf stepb sb, sSize = nb}
= simple step (sa, sb, Nothing) (smaller na nb)
where
{-# INLINE_INNER step #-}
= simple step (sa, sb, Nothing) (smaller na nb)
where
{-# INLINE_INNER step #-}
@@ -593,7 +599,9 @@ zipWithM_ f sa sb = consume (zipWithM f sa sb)

zipWith3M :: Monad m => (a -> b -> c -> m d) -> Stream m v a -> Stream m v b -> Stream m v c -> Stream m v d
{-# INLINE_STREAM zipWith3M #-}

zipWith3M :: Monad m => (a -> b -> c -> m d) -> Stream m v a -> Stream m v b -> Stream m v c -> Stream m v d
{-# INLINE_STREAM zipWith3M #-}
-zipWith3M f (Stream (Unf stepa sa) _ na) (Stream (Unf stepb sb) _ nb) (Stream (Unf stepc sc) _ nc)
+zipWith3M f Stream{sElems = Unf stepa sa, sSize = na}
+            Stream{sElems = Unf stepb sb, sSize = nb}
+            Stream{sElems = Unf stepc sc, sSize = nc}
= simple step (sa, sb, sc, Nothing) (smaller na (smaller nb nc))
where
{-# INLINE_INNER step #-}
= simple step (sa, sb, sc, Nothing) (smaller na (smaller nb nc))
where
{-# INLINE_INNER step #-}
@@ -701,7 +709,7 @@ filter f = filterM (return . f)
-- | Drop elements which do not satisfy the monadic predicate
filterM :: Monad m => (a -> m Bool) -> Stream m v a -> Stream m v a
{-# INLINE_STREAM filterM #-}
-- | Drop elements which do not satisfy the monadic predicate
filterM :: Monad m => (a -> m Bool) -> Stream m v a -> Stream m v a
{-# INLINE_STREAM filterM #-}
-filterM f (Stream (Unf step s) _ n) = simple step' s (toMax n)
+filterM f Stream{sElems = Unf step s, sSize = n} = simple step' s (toMax n)
where
{-# INLINE_INNER step' #-}
step' s = do
where
{-# INLINE_INNER step' #-}
step' s = do
@@ -722,7 +730,7 @@ takeWhile f = takeWhileM (return . f)
-- | Longest prefix of elements that satisfy the monadic predicate
takeWhileM :: Monad m => (a -> m Bool) -> Stream m v a -> Stream m v a
{-# INLINE_STREAM takeWhileM #-}
-- | Longest prefix of elements that satisfy the monadic predicate
takeWhileM :: Monad m => (a -> m Bool) -> Stream m v a -> Stream m v a
{-# INLINE_STREAM takeWhileM #-}
-takeWhileM f (Stream (Unf step s) _ n) = simple step' s (toMax n)
+takeWhileM f Stream{sElems = Unf step s, sSize = n} = simple step' s (toMax n)
where
{-# INLINE_INNER step' #-}
step' s = do
where
{-# INLINE_INNER step' #-}
step' s = do
@@ -744,7 +752,8 @@ data DropWhile s a = DropWhile_Drop s | DropWhile_Yield a s | DropWhile_Next s
-- | Drop the longest prefix of elements that satisfy the monadic predicate
dropWhileM :: Monad m => (a -> m Bool) -> Stream m v a -> Stream m v a
{-# INLINE_STREAM dropWhileM #-}
-- | Drop the longest prefix of elements that satisfy the monadic predicate
dropWhileM :: Monad m => (a -> m Bool) -> Stream m v a -> Stream m v a
{-# INLINE_STREAM dropWhileM #-}
-dropWhileM f (Stream (Unf step s) _ n) = simple step' (DropWhile_Drop s) (toMax n)
+dropWhileM f Stream{sElems = Unf step s, sSize = n}
+  = simple step' (DropWhile_Drop s) (toMax n)
where
-- NOTE: we jump through hoops here to have only one Yield; local data
-- declarations would be nice!
where
-- NOTE: we jump through hoops here to have only one Yield; local data
-- declarations would be nice!
@@ -778,7 +787,7 @@ infix 4 `elem`
-- | Check whether the 'Stream' contains an element
elem :: (Monad m, Eq a) => a -> Stream m v a -> m Bool
{-# INLINE_STREAM elem #-}
-- | Check whether the 'Stream' contains an element
elem :: (Monad m, Eq a) => a -> Stream m v a -> m Bool
{-# INLINE_STREAM elem #-}
-elem x (Stream (Unf step s) _ _) = elem_loop SPEC s
+elem x Stream{sElems = Unf step s} = elem_loop SPEC s
where
elem_loop !sPEC s
= do
where
elem_loop !sPEC s
= do
@@ -805,7 +814,7 @@ find f = findM (return . f)
-- 'Nothing' if no such element exists.
findM :: Monad m => (a -> m Bool) -> Stream m v a -> m (Maybe a)
{-# INLINE_STREAM findM #-}
-- 'Nothing' if no such element exists.
findM :: Monad m => (a -> m Bool) -> Stream m v a -> m (Maybe a)
{-# INLINE_STREAM findM #-}
-findM f (Stream (Unf step s) _ _) = find_loop SPEC s
+findM f Stream{sElems = Unf step s} = find_loop SPEC s
where
find_loop !sPEC s
= do
where
find_loop !sPEC s
= do
@@ -828,7 +837,7 @@ findIndex f = findIndexM (return . f)
-- predicate or 'Nothing' if no such element exists.
findIndexM :: Monad m => (a -> m Bool) -> Stream m v a -> m (Maybe Int)
{-# INLINE_STREAM findIndexM #-}
-- predicate or 'Nothing' if no such element exists.
findIndexM :: Monad m => (a -> m Bool) -> Stream m v a -> m (Maybe Int)
{-# INLINE_STREAM findIndexM #-}
-findIndexM f (Stream (Unf step s) _ _) = findIndex_loop SPEC s 0
+findIndexM f Stream{sElems = Unf step s} = findIndex_loop SPEC s 0
where
findIndex_loop !sPEC s i
= do
where
findIndex_loop !sPEC s i
= do
@@ -852,7 +861,7 @@ foldl f = foldlM (\a b -> return (f a b))
-- | Left fold with a monadic operator
foldlM :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> m a
{-# INLINE_STREAM foldlM #-}
-- | Left fold with a monadic operator
foldlM :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> m a
{-# INLINE_STREAM foldlM #-}
-foldlM m z (Stream (Unf step s) _ _) = foldlM_loop SPEC z s
+foldlM m z Stream{sElems = Unf step s} = foldlM_loop SPEC z s
where
foldlM_loop !sPEC z s
= do
where
foldlM_loop !sPEC z s
= do
@@ -869,7 +878,7 @@ foldM = foldlM

vfoldlM :: Monad m => (a -> Chunk v b -> m a) -> a -> Stream m v b -> m a
{-# INLINE_STREAM vfoldlM #-}

vfoldlM :: Monad m => (a -> Chunk v b -> m a) -> a -> Stream m v b -> m a
{-# INLINE_STREAM vfoldlM #-}
-vfoldlM f z (Stream _ (Unf step s) _) = vfoldlM_loop SPEC z s
+vfoldlM f z Stream{sChunks = Unf step s} = vfoldlM_loop SPEC z s
where
vfoldlM_loop !sPEC z s
= do
where
vfoldlM_loop !sPEC z s
= do
@@ -887,7 +896,7 @@ foldl1 f = foldl1M (\a b -> return (f a b))
-- | Left fold over a non-empty 'Stream' with a monadic operator
foldl1M :: Monad m => (a -> a -> m a) -> Stream m v a -> m a
{-# INLINE_STREAM foldl1M #-}
-- | Left fold over a non-empty 'Stream' with a monadic operator
foldl1M :: Monad m => (a -> a -> m a) -> Stream m v a -> m a
{-# INLINE_STREAM foldl1M #-}
-foldl1M f (Stream (Unf step s) _ sz) = foldl1M_loop SPEC s
+foldl1M f Stream{sElems = Unf step s, sSize = sz} = foldl1M_loop SPEC s
where
foldl1M_loop !sPEC s
= do
where
foldl1M_loop !sPEC s
= do
@@ -910,7 +919,7 @@ foldl' f = foldlM' (\a b -> return (f a b))
-- | Left fold with a strict accumulator and a monadic operator
foldlM' :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> m a
{-# INLINE_STREAM foldlM' #-}
-- | Left fold with a strict accumulator and a monadic operator
foldlM' :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> m a
{-# INLINE_STREAM foldlM' #-}
-foldlM' m z (Stream (Unf step s) _ _) = foldlM'_loop SPEC z s
+foldlM' m z Stream{sElems = Unf step s} = foldlM'_loop SPEC z s
where
foldlM'_loop !sPEC z s
= z `seq`
where
foldlM'_loop !sPEC z s
= z `seq`
@@ -928,7 +937,7 @@ foldM' = foldlM'

vfoldlM' :: Monad m => (a -> Chunk v b -> m a) -> a -> Stream m v b -> m a
{-# INLINE_STREAM vfoldlM' #-}

vfoldlM' :: Monad m => (a -> Chunk v b -> m a) -> a -> Stream m v b -> m a
{-# INLINE_STREAM vfoldlM' #-}
-vfoldlM' f z (Stream _ (Unf step s) _) = vfoldlM'_loop SPEC z s
+vfoldlM' f z Stream{sChunks = Unf step s} = vfoldlM'_loop SPEC z s
where
vfoldlM'_loop !sPEC z s
= z `seq` do
where
vfoldlM'_loop !sPEC z s
= z `seq` do
@@ -947,7 +956,7 @@ foldl1' f = foldl1M' (\a b -> return (f a b))
foldl1M' :: Monad m => (a -> a -> m a) -> Stream m v a -> m a
{-# INLINE_STREAM foldl1M' #-}
foldl1M' :: Monad m => (a -> a -> m a) -> Stream m v a -> m a
{-# INLINE_STREAM foldl1M' #-}
-foldl1M' f (Stream (Unf step s) _ sz) = foldl1M'_loop SPEC s
+foldl1M' f Stream{sElems = Unf step s, sSize = sz} = foldl1M'_loop SPEC s
where
foldl1M'_loop !sPEC s
= do
where
foldl1M'_loop !sPEC s
= do
@@ -970,7 +979,7 @@ foldr f = foldrM (\a b -> return (f a b))
-- | Right fold with a monadic operator
foldrM :: Monad m => (a -> b -> m b) -> b -> Stream m v a -> m b
{-# INLINE_STREAM foldrM #-}
-- | Right fold with a monadic operator
foldrM :: Monad m => (a -> b -> m b) -> b -> Stream m v a -> m b
{-# INLINE_STREAM foldrM #-}
-foldrM f z (Stream (Unf step s) _ _) = foldrM_loop SPEC s
+foldrM f z Stream{sElems = Unf step s} = foldrM_loop SPEC s
where
foldrM_loop !sPEC s
= do
where
foldrM_loop !sPEC s
= do
@@ -988,7 +997,7 @@ foldr1 f = foldr1M (\a b -> return (f a b))
-- | Right fold over a non-empty stream with a monadic operator
foldr1M :: Monad m => (a -> a -> m a) -> Stream m v a -> m a
{-# INLINE_STREAM foldr1M #-}
-- | Right fold over a non-empty stream with a monadic operator
foldr1M :: Monad m => (a -> a -> m a) -> Stream m v a -> m a
{-# INLINE_STREAM foldr1M #-}
-foldr1M f (Stream (Unf step s) _ _) = foldr1M_loop0 SPEC s
+foldr1M f Stream{sElems = Unf step s} = foldr1M_loop0 SPEC s
where
foldr1M_loop0 !sPEC s
= do
where
foldr1M_loop0 !sPEC s
= do
@@ -1011,7 +1020,7 @@ foldr1M f (Stream (Unf step s) _ _) = foldr1M_loop0 SPEC s

and :: Monad m => Stream m v Bool -> m Bool
{-# INLINE_STREAM and #-}

and :: Monad m => Stream m v Bool -> m Bool
{-# INLINE_STREAM and #-}
-and (Stream (Unf step s) _ _) = and_loop SPEC s
+and Stream{sElems = Unf step s} = and_loop SPEC s
where
and_loop !sPEC s
= do
where
and_loop !sPEC s
= do
@@ -1024,7 +1033,7 @@ and (Stream (Unf step s) _ _) = and_loop SPEC s

or :: Monad m => Stream m v Bool -> m Bool
{-# INLINE_STREAM or #-}

or :: Monad m => Stream m v Bool -> m Bool
{-# INLINE_STREAM or #-}
-or (Stream (Unf step s) _ _) = or_loop SPEC s
+or Stream{sElems = Unf step s} = or_loop SPEC s
where
or_loop !sPEC s
= do
where
or_loop !sPEC s
= do
@@ -1041,7 +1050,7 @@ concatMap f = concatMapM (return . f)

concatMapM :: Monad m => (a -> m (Stream m v b)) -> Stream m v a -> Stream m v b
{-# INLINE_STREAM concatMapM #-}

concatMapM :: Monad m => (a -> m (Stream m v b)) -> Stream m v a -> Stream m v b
{-# INLINE_STREAM concatMapM #-}
-concatMapM f (Stream (Unf step s) _ _) = simple concatMap_go (Left s) Unknown
+concatMapM f Stream{sElems = Unf step s} = simple concatMap_go (Left s) Unknown
where
concatMap_go (Left s) = do
r <- step s
where
concatMap_go (Left s) = do
r <- step s
@@ -1062,7 +1071,7 @@ concatMapM f (Stream (Unf step s) _ _) = simple concatMap_go (Left s) Unknown
flatten :: Monad m => (a -> m s) -> (s -> m (Step s b)) -> Size
-> Stream m v a -> Stream m v b
{-# INLINE_STREAM flatten #-}
flatten :: Monad m => (a -> m s) -> (s -> m (Step s b)) -> Size
-> Stream m v a -> Stream m v b
{-# INLINE_STREAM flatten #-}
-flatten mk istep sz (Stream (Unf ostep t) _ _) = simple step (Left t) sz
+flatten mk istep sz Stream{sElems = Unf ostep t} = simple step (Left t) sz
where
{-# INLINE_INNER step #-}
step (Left t) = do
where
{-# INLINE_INNER step #-}
step (Left t) = do
@@ -1147,7 +1156,7 @@ prescanl f = prescanlM (\a b -> return (f a b))
-- | Prefix scan with a monadic operator
prescanlM :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> Stream m v a
{-# INLINE_STREAM prescanlM #-}
-- | Prefix scan with a monadic operator
prescanlM :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> Stream m v a
{-# INLINE_STREAM prescanlM #-}
-prescanlM f z (Stream (Unf step s) _ sz) = simple step' (s,z) sz
+prescanlM f z Stream{sElems = Unf step s, sSize = sz} = simple step' (s,z) sz
where
{-# INLINE_INNER step' #-}
step' (s,x) = do
where
{-# INLINE_INNER step' #-}
step' (s,x) = do
@@ -1167,7 +1176,7 @@ prescanl' f = prescanlM' (\a b -> return (f a b))
-- | Prefix scan with strict accumulator and a monadic operator
prescanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> Stream m v a
{-# INLINE_STREAM prescanlM' #-}
-- | Prefix scan with strict accumulator and a monadic operator
prescanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> Stream m v a
{-# INLINE_STREAM prescanlM' #-}
-prescanlM' f z (Stream (Unf step s) _ sz) = simple step' (s,z) sz
+prescanlM' f z Stream{sElems = Unf step s, sSize = sz} = simple step' (s,z) sz
where
{-# INLINE_INNER step' #-}
step' (s,x) = x `seq`
where
{-# INLINE_INNER step' #-}
step' (s,x) = x `seq`
@@ -1188,7 +1197,7 @@ postscanl f = postscanlM (\a b -> return (f a b))
-- | Suffix scan with a monadic operator
postscanlM :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> Stream m v a
{-# INLINE_STREAM postscanlM #-}
-- | Suffix scan with a monadic operator
postscanlM :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> Stream m v a
{-# INLINE_STREAM postscanlM #-}
-postscanlM f z (Stream (Unf step s) _ sz) = simple step' (s,z) sz
+postscanlM f z Stream{sElems = Unf step s, sSize = sz} = simple step' (s,z) sz
where
{-# INLINE_INNER step' #-}
step' (s,x) = do
where
{-# INLINE_INNER step' #-}
step' (s,x) = do
@@ -1208,7 +1217,8 @@ postscanl' f = postscanlM' (\a b -> return (f a b))
-- | Suffix scan with strict acccumulator and a monadic operator
postscanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> Stream m v a
{-# INLINE_STREAM postscanlM' #-}
-- | Suffix scan with strict acccumulator and a monadic operator
postscanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m v b -> Stream m v a
{-# INLINE_STREAM postscanlM' #-}
-postscanlM' f z (Stream (Unf step s) _ sz) = z `seq` simple step' (s,z) sz
+postscanlM' f z Stream{sElems = Unf step s, sSize = sz}
+  = z `seq` simple step' (s,z) sz
where
{-# INLINE_INNER step' #-}
step' (s,x) = x `seq`
where
{-# INLINE_INNER step' #-}
step' (s,x) = x `seq`
@@ -1249,7 +1259,7 @@ scanl1 f = scanl1M (\x y -> return (f x y))
-- | Scan over a non-empty 'Stream' with a monadic operator
scanl1M :: Monad m => (a -> a -> m a) -> Stream m v a -> Stream m v a
{-# INLINE_STREAM scanl1M #-}
-- | Scan over a non-empty 'Stream' with a monadic operator
scanl1M :: Monad m => (a -> a -> m a) -> Stream m v a -> Stream m v a
{-# INLINE_STREAM scanl1M #-}
-scanl1M f (Stream (Unf step s) _ sz) = simple step' (s, Nothing) sz
+scanl1M f Stream{sElems = Unf step s, sSize = sz} = simple step' (s, Nothing) sz
where
{-# INLINE_INNER step' #-}
step' (s, Nothing) = do
where
{-# INLINE_INNER step' #-}
step' (s, Nothing) = do
@@ -1277,7 +1287,8 @@ scanl1' f = scanl1M' (\x y -> return (f x y))
-- operator
scanl1M' :: Monad m => (a -> a -> m a) -> Stream m v a -> Stream m v a
{-# INLINE_STREAM scanl1M' #-}
-- operator
scanl1M' :: Monad m => (a -> a -> m a) -> Stream m v a -> Stream m v a
{-# INLINE_STREAM scanl1M' #-}
-scanl1M' f (Stream (Unf step s) _ sz) = simple step' (s, Nothing) sz
+scanl1M' f Stream{sElems = Unf step s, sSize = sz}
+  = simple step' (s, Nothing) sz
where
{-# INLINE_INNER step' #-}
step' (s, Nothing) = do
where
{-# INLINE_INNER step' #-}
step' (s, Nothing) = do
@@ -1633,7 +1644,7 @@ fromVectors vs = Stream (Unf pstep (Left vs))

reVector :: Monad m => Stream m u a -> Stream m v a
{-# INLINE_STREAM reVector #-}

reVector :: Monad m => Stream m u a -> Stream m v a
{-# INLINE_STREAM reVector #-}
-reVector (Stream (Unf step s) _ n) = simple step s n
+reVector Stream{sElems = Unf step s, sSize = n} = simple step s n

{-# RULES

{-# RULES