{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE UndecidableInstances #-}
#include "inline.hs"
module Streamly.Internal.Data.Stream.StreamK
(
IsStream (..)
, adapt
, Stream(..)
, mkStream
, nil
, nilM
, cons
, (.:)
, foldStream
, foldStreamShared
, unShare
, uncons
, unfoldr
, unfoldrM
, repeat
, repeatM
, replicate
, replicateM
, fromIndices
, fromIndicesM
, iterate
, iterateM
, yield
, yieldM
, fromFoldable
, fromList
, fromStreamK
, foldrS
, foldrSM
, buildS
, buildM
, augmentS
, augmentSM
, foldr
, foldr1
, foldrM
, foldrT
, foldl'
, foldlM'
, foldlS
, foldlT
, foldlx'
, foldlMx'
, drain
, null
, head
, tail
, init
, elem
, notElem
, all
, any
, last
, minimum
, minimumBy
, maximum
, maximumBy
, findIndices
, lookup
, findM
, find
, (!!)
, mapM_
, toList
, toStreamK
, hoist
, scanl'
, scanlx'
, filter
, take
, takeWhile
, drop
, dropWhile
, map
, mapM
, mapMSerial
, sequence
, intersperseM
, intersperse
, insertBy
, deleteBy
, reverse
, mapMaybe
, zipWith
, zipWithM
, mergeBy
, mergeByM
, concatMapBy
, concatMap
, bindWith
, the
, serial
, consMStream
, withLocal
, mfix
, Streaming
, once
)
where
import Control.Monad.Trans (MonadTrans(lift))
import Control.Monad (void, join)
import Control.Monad.Reader.Class (MonadReader(..))
import Data.Function (fix)
import Prelude
hiding (foldl, foldr, last, map, mapM, mapM_, repeat, sequence,
take, filter, all, any, takeWhile, drop, dropWhile, minimum,
maximum, elem, notElem, null, head, tail, init, zipWith, lookup,
foldr1, (!!), replicate, reverse, concatMap, iterate)
import qualified Prelude
import Streamly.Internal.Data.SVar
import Streamly.Internal.Data.Stream.StreamK.Type
{-# INLINE uncons #-}
uncons :: (IsStream t, Monad m) => t m a -> m (Maybe (a, t m a))
uncons :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m (Maybe (a, t m a))
uncons t m a
m =
let stop :: m (Maybe a)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
single :: a -> m (Maybe (a, t m a))
single a
a = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just (a
a, forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil))
yieldk :: a -> b -> m (Maybe (a, b))
yieldk a
a b
r = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just (a
a, b
r))
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState forall {m :: * -> *} {a} {b}. Monad m => a -> b -> m (Maybe (a, b))
yieldk forall {m :: * -> *} {t :: (* -> *) -> * -> *} {a} {m :: * -> *}
{a}.
(Monad m, IsStream t) =>
a -> m (Maybe (a, t m a))
single forall {a}. m (Maybe a)
stop t m a
m
{-# INLINE unfoldr #-}
unfoldr :: IsStream t => (b -> Maybe (a, b)) -> b -> t m a
unfoldr :: forall (t :: (* -> *) -> * -> *) b a (m :: * -> *).
IsStream t =>
(b -> Maybe (a, b)) -> b -> t m a
unfoldr b -> Maybe (a, b)
next b
s0 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall b. (a -> b -> b) -> b -> b) -> t m a
build forall a b. (a -> b) -> a -> b
$ \a -> b -> b
yld b
stp ->
let go :: b -> b
go b
s =
case b -> Maybe (a, b)
next b
s of
Just (a
a, b
b) -> a -> b -> b
yld a
a (b -> b
go b
b)
Maybe (a, b)
Nothing -> b
stp
in b -> b
go b
s0
{-# INLINE unfoldrM #-}
unfoldrM :: (IsStream t, MonadAsync m) => (b -> m (Maybe (a, b))) -> b -> t m a
unfoldrM :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) b a.
(IsStream t, MonadAsync m) =>
(b -> m (Maybe (a, b))) -> b -> t m a
unfoldrM b -> m (Maybe (a, b))
step = forall {t :: (* -> *) -> * -> *}. IsStream t => b -> t m a
go
where
go :: b -> t m a
go b
s = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
(forall r. (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
sharedM forall a b. (a -> b) -> a -> b
$ \a -> t m a -> m r
yld a -> m r
_ m r
stp -> do
Maybe (a, b)
r <- b -> m (Maybe (a, b))
step b
s
case Maybe (a, b)
r of
Just (a
a, b
b) -> a -> t m a -> m r
yld a
a (b -> t m a
go b
b)
Maybe (a, b)
Nothing -> m r
stp
{-# DEPRECATED once "Please use yieldM instead." #-}
{-# INLINE once #-}
once :: (Monad m, IsStream t) => m a -> t m a
once :: forall (m :: * -> *) (t :: (* -> *) -> * -> *) a.
(Monad m, IsStream t) =>
m a -> t m a
once = forall (m :: * -> *) (t :: (* -> *) -> * -> *) a.
(Monad m, IsStream t) =>
m a -> t m a
yieldM
repeatM :: (IsStream t, MonadAsync m) => m a -> t m a
repeatM :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a
repeatM = forall {t :: (* -> *) -> * -> *} {m :: * -> *} {a}.
(IsStream t, MonadIO m, MonadBaseControl IO m, MonadThrow m) =>
m a -> t m a
go
where go :: m a -> t m a
go m a
m = m a
m forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a -> t m a
|: m a -> t m a
go m a
m
{-# INLINE repeat #-}
repeat :: IsStream t => a -> t m a
repeat :: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a
repeat a
a = let x :: t m a
x = forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
cons a
a t m a
x in forall {m :: * -> *}. t m a
x
{-# INLINE replicateM #-}
replicateM :: (IsStream t, MonadAsync m) => Int -> m a -> t m a
replicateM :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
Int -> m a -> t m a
replicateM Int
n m a
m = forall {t} {t :: (* -> *) -> * -> *}.
(Ord t, Num t, IsStream t) =>
t -> t m a
go Int
n
where
go :: t -> t m a
go t
cnt = if t
cnt forall a. Ord a => a -> a -> Bool
<= t
0 then forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil else m a
m forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a -> t m a
|: t -> t m a
go (t
cnt forall a. Num a => a -> a -> a
- t
1)
{-# INLINE replicate #-}
replicate :: IsStream t => Int -> a -> t m a
replicate :: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
Int -> a -> t m a
replicate Int
n a
a = forall {t} {t :: (* -> *) -> * -> *} {m :: * -> *}.
(Ord t, Num t, IsStream t) =>
t -> t m a
go Int
n
where
go :: t -> t m a
go t
cnt = if t
cnt forall a. Ord a => a -> a -> Bool
<= t
0 then forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil else a
a forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
`cons` t -> t m a
go (t
cnt forall a. Num a => a -> a -> a
- t
1)
{-# INLINE fromIndicesM #-}
fromIndicesM :: (IsStream t, MonadAsync m) => (Int -> m a) -> t m a
fromIndicesM :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
(Int -> m a) -> t m a
fromIndicesM Int -> m a
gen = forall {t :: (* -> *) -> * -> *}. IsStream t => Int -> t m a
go Int
0
where
go :: Int -> t m a
go Int
i = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
stp a -> m r
sng m r
yld -> do
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStreamShared State Stream m a
st a -> t m a -> m r
stp a -> m r
sng m r
yld (Int -> m a
gen Int
i forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a -> t m a
|: Int -> t m a
go (Int
i forall a. Num a => a -> a -> a
+ Int
1))
{-# INLINE fromIndices #-}
fromIndices :: IsStream t => (Int -> a) -> t m a
fromIndices :: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
(Int -> a) -> t m a
fromIndices Int -> a
gen = forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
IsStream t =>
Int -> t m a
go Int
0
where
go :: Int -> t m a
go Int
n = (Int -> a
gen Int
n) forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
`cons` Int -> t m a
go (Int
n forall a. Num a => a -> a -> a
+ Int
1)
{-# INLINE iterate #-}
iterate :: IsStream t => (a -> a) -> a -> t m a
iterate :: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
(a -> a) -> a -> t m a
iterate a -> a
step = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
Stream m a -> t m a
fromStream forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
IsStream t =>
a -> t m a
go
where
go :: a -> t m a
go a
s = forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
cons a
s (a -> t m a
go (a -> a
step a
s))
{-# INLINE iterateM #-}
iterateM :: (IsStream t, MonadAsync m) => (a -> m a) -> m a -> t m a
iterateM :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
(a -> m a) -> m a -> t m a
iterateM a -> m a
step = forall {t :: (* -> *) -> * -> *}. IsStream t => m a -> t m a
go
where
go :: m a -> t m a
go m a
s = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
stp a -> m r
sng m r
yld -> do
a
next <- m a
s
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStreamShared State Stream m a
st a -> t m a -> m r
stp a -> m r
sng m r
yld (forall (m :: * -> *) a. Monad m => a -> m a
return a
next forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a -> t m a
|: m a -> t m a
go (a -> m a
step a
next))
{-# INLINE fromFoldable #-}
fromFoldable :: (IsStream t, Foldable f) => f a -> t m a
fromFoldable :: forall (t :: (* -> *) -> * -> *) (f :: * -> *) a (m :: * -> *).
(IsStream t, Foldable f) =>
f a -> t m a
fromFoldable = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
cons forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil
{-# INLINE fromList #-}
fromList :: IsStream t => [a] -> t m a
fromList :: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
[a] -> t m a
fromList = forall (t :: (* -> *) -> * -> *) (f :: * -> *) a (m :: * -> *).
(IsStream t, Foldable f) =>
f a -> t m a
fromFoldable
{-# INLINE fromStreamK #-}
fromStreamK :: IsStream t => Stream m a -> t m a
fromStreamK :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
Stream m a -> t m a
fromStreamK = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
Stream m a -> t m a
fromStream
{-# INLINE foldr #-}
foldr :: (IsStream t, Monad m) => (a -> b -> b) -> b -> t m a -> m b
foldr :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a b.
(IsStream t, Monad m) =>
(a -> b -> b) -> b -> t m a -> m b
foldr a -> b -> b
step b
acc = forall (t :: (* -> *) -> * -> *) a (m :: * -> *) b.
IsStream t =>
(a -> m b -> m b) -> m b -> t m a -> m b
foldrM (\a
x m b
xs -> m b
xs forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \b
b -> forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> b
step a
x b
b)) (forall (m :: * -> *) a. Monad m => a -> m a
return b
acc)
{-# INLINE foldrT #-}
foldrT :: (IsStream t, Monad m, Monad (s m), MonadTrans s)
=> (a -> s m b -> s m b) -> s m b -> t m a -> s m b
foldrT :: forall (t :: (* -> *) -> * -> *) (m :: * -> *)
(s :: (* -> *) -> * -> *) a b.
(IsStream t, Monad m, Monad (s m), MonadTrans s) =>
(a -> s m b -> s m b) -> s m b -> t m a -> s m b
foldrT a -> s m b -> s m b
step s m b
final t m a
m = forall {t :: (* -> *) -> * -> *}. IsStream t => t m a -> s m b
go t m a
m
where
go :: t m a -> s m b
go t m a
m1 = do
Maybe (a, t m a)
res <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m (Maybe (a, t m a))
uncons t m a
m1
case Maybe (a, t m a)
res of
Just (a
h, t m a
t) -> a -> s m b -> s m b
step a
h (t m a -> s m b
go t m a
t)
Maybe (a, t m a)
Nothing -> s m b
final
{-# INLINE foldr1 #-}
foldr1 :: (IsStream t, Monad m) => (a -> a -> a) -> t m a -> m (Maybe a)
foldr1 :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(a -> a -> a) -> t m a -> m (Maybe a)
foldr1 a -> a -> a
step t m a
m = do
Maybe (a, t m a)
r <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m (Maybe (a, t m a))
uncons t m a
m
case Maybe (a, t m a)
r of
Maybe (a, t m a)
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
Just (a
h, t m a
t) -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Maybe a
Just (forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
(IsStream t, Monad m) =>
a -> t m a -> m a
go a
h t m a
t)
where
go :: a -> t m a -> m a
go a
p t m a
m1 =
let stp :: m a
stp = forall (m :: * -> *) a. Monad m => a -> m a
return a
p
single :: a -> m a
single a
a = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ a -> a -> a
step a
a a
p
yieldk :: a -> t m a -> m a
yieldk a
a t m a
r = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a -> a -> a
step a
p) (a -> t m a -> m a
go a
a t m a
r)
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m a
yieldk forall {m :: * -> *}. Monad m => a -> m a
single m a
stp t m a
m1
{-# INLINE foldlx' #-}
foldlx' :: forall t m a b x. (IsStream t, Monad m)
=> (x -> a -> x) -> x -> (x -> b) -> t m a -> m b
foldlx' :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a b x.
(IsStream t, Monad m) =>
(x -> a -> x) -> x -> (x -> b) -> t m a -> m b
foldlx' x -> a -> x
step x
begin x -> b
done t m a
m = t m x -> m b
get forall a b. (a -> b) -> a -> b
$ t m a -> x -> t m x
go t m a
m x
begin
where
{-# NOINLINE get #-}
get :: t m x -> m b
get :: t m x -> m b
get t m x
m1 =
let single :: x -> m b
single = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. x -> b
done
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStreamShared forall a. HasCallStack => a
undefined forall a. HasCallStack => a
undefined x -> m b
single forall a. HasCallStack => a
undefined t m x
m1
go :: t m a -> x -> t m x
go :: t m a -> x -> t m x
go t m a
m1 !x
acc = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m x
_ x -> t m x -> m r
yld x -> m r
sng m r
_ ->
let stop :: m r
stop = x -> m r
sng x
acc
single :: a -> m r
single a
a = x -> m r
sng forall a b. (a -> b) -> a -> b
$ x -> a -> x
step x
acc a
a
yieldk :: a -> t m a -> m r
yieldk a
a t m a
r = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState x -> t m x -> m r
yld x -> m r
sng forall a. HasCallStack => a
undefined forall a b. (a -> b) -> a -> b
$
t m a -> x -> t m x
go t m a
r (x -> a -> x
step x
acc a
a)
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m r
yieldk a -> m r
single m r
stop t m a
m1
{-# INLINE foldl' #-}
foldl' :: (IsStream t, Monad m) => (b -> a -> b) -> b -> t m a -> m b
foldl' :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) b a.
(IsStream t, Monad m) =>
(b -> a -> b) -> b -> t m a -> m b
foldl' b -> a -> b
step b
begin = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a b x.
(IsStream t, Monad m) =>
(x -> a -> x) -> x -> (x -> b) -> t m a -> m b
foldlx' b -> a -> b
step b
begin forall a. a -> a
id
{-# INLINABLE foldlMx' #-}
foldlMx' :: (IsStream t, Monad m)
=> (x -> a -> m x) -> m x -> (x -> m b) -> t m a -> m b
foldlMx' :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) x a b.
(IsStream t, Monad m) =>
(x -> a -> m x) -> m x -> (x -> m b) -> t m a -> m b
foldlMx' x -> a -> m x
step m x
begin x -> m b
done t m a
m = forall {t :: (* -> *) -> * -> *}. IsStream t => m x -> t m a -> m b
go m x
begin t m a
m
where
go :: m x -> t m a -> m b
go !m x
acc t m a
m1 =
let stop :: m b
stop = m x
acc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= x -> m b
done
single :: a -> m b
single a
a = m x
acc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \x
b -> x -> a -> m x
step x
b a
a forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= x -> m b
done
yieldk :: a -> t m a -> m b
yieldk a
a t m a
r = m x
acc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \x
b -> x -> a -> m x
step x
b a
a forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \x
x -> m x -> t m a -> m b
go (forall (m :: * -> *) a. Monad m => a -> m a
return x
x) t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m b
yieldk a -> m b
single m b
stop t m a
m1
{-# INLINE foldlM' #-}
foldlM' :: (IsStream t, Monad m) => (b -> a -> m b) -> b -> t m a -> m b
foldlM' :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) b a.
(IsStream t, Monad m) =>
(b -> a -> m b) -> b -> t m a -> m b
foldlM' b -> a -> m b
step b
begin = forall (t :: (* -> *) -> * -> *) (m :: * -> *) x a b.
(IsStream t, Monad m) =>
(x -> a -> m x) -> m x -> (x -> m b) -> t m a -> m b
foldlMx' b -> a -> m b
step (forall (m :: * -> *) a. Monad m => a -> m a
return b
begin) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINE foldlS #-}
foldlS :: IsStream t => (t m b -> a -> t m b) -> t m b -> t m a -> t m b
foldlS :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) b a.
IsStream t =>
(t m b -> a -> t m b) -> t m b -> t m a -> t m b
foldlS t m b -> a -> t m b
step t m b
begin t m a
m = forall {t :: (* -> *) -> * -> *}.
IsStream t =>
t m b -> t m a -> t m b
go t m b
begin t m a
m
where
go :: t m b -> t m a -> t m b
go t m b
acc t m a
rest = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m b
st b -> t m b -> m r
yld b -> m r
sng m r
stp ->
let run :: t m b -> m r
run t m b
x = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m b
st b -> t m b -> m r
yld b -> m r
sng m r
stp t m b
x
stop :: m r
stop = t m b -> m r
run t m b
acc
single :: a -> m r
single a
a = t m b -> m r
run forall a b. (a -> b) -> a -> b
$ t m b -> a -> t m b
step t m b
acc a
a
yieldk :: a -> t m a -> m r
yieldk a
a t m a
r = t m b -> m r
run forall a b. (a -> b) -> a -> b
$ t m b -> t m a -> t m b
go (t m b -> a -> t m b
step t m b
acc a
a) t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream m b
st) a -> t m a -> m r
yieldk a -> m r
single m r
stop t m a
rest
{-# INLINE foldlT #-}
foldlT :: (IsStream t, Monad m, Monad (s m), MonadTrans s)
=> (s m b -> a -> s m b) -> s m b -> t m a -> s m b
foldlT :: forall (t :: (* -> *) -> * -> *) (m :: * -> *)
(s :: (* -> *) -> * -> *) b a.
(IsStream t, Monad m, Monad (s m), MonadTrans s) =>
(s m b -> a -> s m b) -> s m b -> t m a -> s m b
foldlT s m b -> a -> s m b
step s m b
begin t m a
m = forall {t :: (* -> *) -> * -> *}.
IsStream t =>
s m b -> t m a -> s m b
go s m b
begin t m a
m
where
go :: s m b -> t m a -> s m b
go s m b
acc t m a
m1 = do
Maybe (a, t m a)
res <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m (Maybe (a, t m a))
uncons t m a
m1
case Maybe (a, t m a)
res of
Just (a
h, t m a
t) -> s m b -> t m a -> s m b
go (s m b -> a -> s m b
step s m b
acc a
h) t m a
t
Maybe (a, t m a)
Nothing -> s m b
acc
{-# INLINE drain #-}
drain :: (Monad m, IsStream t) => t m a -> m ()
drain :: forall (m :: * -> *) (t :: (* -> *) -> * -> *) a.
(Monad m, IsStream t) =>
t m a -> m ()
drain = forall (t :: (* -> *) -> * -> *) a (m :: * -> *) b.
IsStream t =>
(a -> m b -> m b) -> m b -> t m a -> m b
foldrM (\a
_ m ()
xs -> m ()
xs) (forall (m :: * -> *) a. Monad m => a -> m a
return ())
{-# INLINE null #-}
null :: (IsStream t, Monad m) => t m a -> m Bool
null :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m Bool
null t m a
m =
let stop :: m Bool
stop = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
single :: p -> m Bool
single p
_ = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
yieldk :: p -> p -> m Bool
yieldk p
_ p
_ = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState forall {m :: * -> *} {p} {p}. Monad m => p -> p -> m Bool
yieldk forall {m :: * -> *} {p}. Monad m => p -> m Bool
single m Bool
stop t m a
m
{-# INLINE head #-}
head :: (IsStream t, Monad m) => t m a -> m (Maybe a)
head :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m (Maybe a)
head t m a
m =
let stop :: m (Maybe a)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
single :: a -> m (Maybe a)
single a
a = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
a)
yieldk :: a -> p -> m (Maybe a)
yieldk a
a p
_ = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
a)
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState forall {m :: * -> *} {a} {p}. Monad m => a -> p -> m (Maybe a)
yieldk forall {m :: * -> *} {a}. Monad m => a -> m (Maybe a)
single forall {a}. m (Maybe a)
stop t m a
m
{-# INLINE tail #-}
tail :: (IsStream t, Monad m) => t m a -> m (Maybe (t m a))
tail :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m (Maybe (t m a))
tail t m a
m =
let stop :: m (Maybe a)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
single :: p -> m (Maybe (t m a))
single p
_ = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil
yieldk :: p -> a -> m (Maybe a)
yieldk p
_ a
r = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState forall {m :: * -> *} {p} {a}. Monad m => p -> a -> m (Maybe a)
yieldk forall {m :: * -> *} {t :: (* -> *) -> * -> *} {p} {m :: * -> *}
{a}.
(Monad m, IsStream t) =>
p -> m (Maybe (t m a))
single forall {a}. m (Maybe a)
stop t m a
m
{-# INLINE headPartial #-}
headPartial :: (IsStream t, Monad m) => t m a -> m a
headPartial :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m a
headPartial = forall (t :: (* -> *) -> * -> *) a (m :: * -> *) b.
IsStream t =>
(a -> m b -> m b) -> m b -> t m a -> m b
foldrM (\a
x m a
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return a
x) (forall a. HasCallStack => [Char] -> a
error [Char]
"head of nil")
{-# INLINE tailPartial #-}
tailPartial :: IsStream t => t m a -> t m a
tailPartial :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a -> t m a
tailPartial t m a
m = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp ->
let stop :: a
stop = forall a. HasCallStack => [Char] -> a
error [Char]
"tail of nil"
single :: p -> m r
single p
_ = m r
stp
yieldk :: p -> t m a -> m r
yieldk p
_ t m a
r = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st forall {p}. p -> t m a -> m r
yieldk forall {p}. p -> m r
single forall {a}. a
stop t m a
m
mfix :: (IsStream t, Monad m) => (m a -> t m a) -> t m a
mfix :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(m a -> t m a) -> t m a
mfix m a -> t m a
f = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp ->
let single :: a -> m r
single a
a = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp forall a b. (a -> b) -> a -> b
$ a
a forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
`cons` t m a
ys
yieldk :: a -> p -> m r
yieldk a
a p
_ = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp forall a b. (a -> b) -> a -> b
$ a
a forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
`cons` t m a
ys
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st forall {p}. a -> p -> m r
yieldk a -> m r
single m r
stp t m a
xs
where xs :: t m a
xs = forall a. (a -> a) -> a
fix (m a -> t m a
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m a
headPartial)
ys :: t m a
ys = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(m a -> t m a) -> t m a
mfix (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a -> t m a
tailPartial forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> t m a
f)
{-# INLINE init #-}
init :: (IsStream t, Monad m) => t m a -> m (Maybe (t m a))
init :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m (Maybe (t m a))
init t m a
m = forall {m :: * -> *} {t :: (* -> *) -> * -> *}
{t :: (* -> *) -> * -> *} {t}.
(Monad m, IsStream t, IsStream t) =>
t m t -> m (Maybe (t m t))
go1 t m a
m
where
go1 :: t m t -> m (Maybe (t m t))
go1 t m t
m1 = do
Maybe (t, t m t)
r <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m (Maybe (a, t m a))
uncons t m t
m1
case Maybe (t, t m t)
r of
Maybe (t, t m t)
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
Just (t
h, t m t
t) -> forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall {t :: (* -> *) -> * -> *} {t :: (* -> *) -> * -> *} {t}
{m :: * -> *}.
(IsStream t, IsStream t) =>
t -> t m t -> t m t
go t
h t m t
t
go :: t -> t m t -> t m t
go t
p t m t
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m t
_ t -> t m t -> m r
yld t -> m r
sng m r
stp ->
let single :: p -> m r
single p
_ = t -> m r
sng t
p
yieldk :: t -> t m t -> m r
yieldk t
a t m t
x = t -> t m t -> m r
yld t
p forall a b. (a -> b) -> a -> b
$ t -> t m t -> t m t
go t
a t m t
x
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState t -> t m t -> m r
yieldk forall {p}. p -> m r
single m r
stp t m t
m1
{-# INLINE elem #-}
elem :: (IsStream t, Monad m, Eq a) => a -> t m a -> m Bool
elem :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m, Eq a) =>
a -> t m a -> m Bool
elem a
e t m a
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
(IsStream t, Monad m) =>
t m a -> m Bool
go t m a
m
where
go :: t m a -> m Bool
go t m a
m1 =
let stop :: m Bool
stop = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
single :: a -> m Bool
single a
a = forall (m :: * -> *) a. Monad m => a -> m a
return (a
a forall a. Eq a => a -> a -> Bool
== a
e)
yieldk :: a -> t m a -> m Bool
yieldk a
a t m a
r = if a
a forall a. Eq a => a -> a -> Bool
== a
e then forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True else t m a -> m Bool
go t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m Bool
yieldk forall {m :: * -> *}. Monad m => a -> m Bool
single m Bool
stop t m a
m1
{-# INLINE notElem #-}
notElem :: (IsStream t, Monad m, Eq a) => a -> t m a -> m Bool
notElem :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m, Eq a) =>
a -> t m a -> m Bool
notElem a
e t m a
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
(IsStream t, Monad m) =>
t m a -> m Bool
go t m a
m
where
go :: t m a -> m Bool
go t m a
m1 =
let stop :: m Bool
stop = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
single :: a -> m Bool
single a
a = forall (m :: * -> *) a. Monad m => a -> m a
return (a
a forall a. Eq a => a -> a -> Bool
/= a
e)
yieldk :: a -> t m a -> m Bool
yieldk a
a t m a
r = if a
a forall a. Eq a => a -> a -> Bool
== a
e then forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False else t m a -> m Bool
go t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m Bool
yieldk forall {m :: * -> *}. Monad m => a -> m Bool
single m Bool
stop t m a
m1
{-# INLINABLE all #-}
all :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m Bool
all :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(a -> Bool) -> t m a -> m Bool
all a -> Bool
p t m a
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
(IsStream t, Monad m) =>
t m a -> m Bool
go t m a
m
where
go :: t m a -> m Bool
go t m a
m1 =
let single :: a -> m Bool
single a
a | a -> Bool
p a
a = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
| Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
yieldk :: a -> t m a -> m Bool
yieldk a
a t m a
r | a -> Bool
p a
a = t m a -> m Bool
go t m a
r
| Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m Bool
yieldk forall {m :: * -> *}. Monad m => a -> m Bool
single (forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True) t m a
m1
{-# INLINABLE any #-}
any :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m Bool
any :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(a -> Bool) -> t m a -> m Bool
any a -> Bool
p t m a
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
(IsStream t, Monad m) =>
t m a -> m Bool
go t m a
m
where
go :: t m a -> m Bool
go t m a
m1 =
let single :: a -> m Bool
single a
a | a -> Bool
p a
a = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
| Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
yieldk :: a -> t m a -> m Bool
yieldk a
a t m a
r | a -> Bool
p a
a = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
| Bool
otherwise = t m a -> m Bool
go t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m Bool
yieldk forall {m :: * -> *}. Monad m => a -> m Bool
single (forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False) t m a
m1
{-# INLINE last #-}
last :: (IsStream t, Monad m) => t m a -> m (Maybe a)
last :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m (Maybe a)
last = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a b x.
(IsStream t, Monad m) =>
(x -> a -> x) -> x -> (x -> b) -> t m a -> m b
foldlx' (\Maybe a
_ a
y -> forall a. a -> Maybe a
Just a
y) forall a. Maybe a
Nothing forall a. a -> a
id
{-# INLINE minimum #-}
minimum :: (IsStream t, Monad m, Ord a) => t m a -> m (Maybe a)
minimum :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m, Ord a) =>
t m a -> m (Maybe a)
minimum t m a
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *} {a}.
(IsStream t, Ord a, Monad m) =>
Maybe a -> t m a -> m (Maybe a)
go forall a. Maybe a
Nothing t m a
m
where
go :: Maybe a -> t m a -> m (Maybe a)
go Maybe a
Nothing t m a
m1 =
let stop :: m (Maybe a)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
single :: a -> m (Maybe a)
single a
a = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
a)
yieldk :: a -> t m a -> m (Maybe a)
yieldk a
a t m a
r = Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
a) t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m (Maybe a)
yieldk forall {m :: * -> *} {a}. Monad m => a -> m (Maybe a)
single forall {a}. m (Maybe a)
stop t m a
m1
go (Just a
res) t m a
m1 =
let stop :: m (Maybe a)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
res)
single :: a -> m (Maybe a)
single a
a =
if a
res forall a. Ord a => a -> a -> Bool
<= a
a
then forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
res)
else forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
a)
yieldk :: a -> t m a -> m (Maybe a)
yieldk a
a t m a
r =
if a
res forall a. Ord a => a -> a -> Bool
<= a
a
then Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
res) t m a
r
else Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
a) t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m (Maybe a)
yieldk forall {m :: * -> *}. Monad m => a -> m (Maybe a)
single m (Maybe a)
stop t m a
m1
{-# INLINE minimumBy #-}
minimumBy
:: (IsStream t, Monad m)
=> (a -> a -> Ordering) -> t m a -> m (Maybe a)
minimumBy :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(a -> a -> Ordering) -> t m a -> m (Maybe a)
minimumBy a -> a -> Ordering
cmp t m a
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
(IsStream t, Monad m) =>
Maybe a -> t m a -> m (Maybe a)
go forall a. Maybe a
Nothing t m a
m
where
go :: Maybe a -> t m a -> m (Maybe a)
go Maybe a
Nothing t m a
m1 =
let stop :: m (Maybe a)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
single :: a -> m (Maybe a)
single a
a = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
a)
yieldk :: a -> t m a -> m (Maybe a)
yieldk a
a t m a
r = Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
a) t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m (Maybe a)
yieldk forall {m :: * -> *} {a}. Monad m => a -> m (Maybe a)
single forall {a}. m (Maybe a)
stop t m a
m1
go (Just a
res) t m a
m1 =
let stop :: m (Maybe a)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
res)
single :: a -> m (Maybe a)
single a
a = case a -> a -> Ordering
cmp a
res a
a of
Ordering
GT -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
a)
Ordering
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
res)
yieldk :: a -> t m a -> m (Maybe a)
yieldk a
a t m a
r = case a -> a -> Ordering
cmp a
res a
a of
Ordering
GT -> Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
a) t m a
r
Ordering
_ -> Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
res) t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m (Maybe a)
yieldk forall {m :: * -> *}. Monad m => a -> m (Maybe a)
single m (Maybe a)
stop t m a
m1
{-# INLINE maximum #-}
maximum :: (IsStream t, Monad m, Ord a) => t m a -> m (Maybe a)
maximum :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m, Ord a) =>
t m a -> m (Maybe a)
maximum t m a
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *} {a}.
(IsStream t, Ord a, Monad m) =>
Maybe a -> t m a -> m (Maybe a)
go forall a. Maybe a
Nothing t m a
m
where
go :: Maybe a -> t m a -> m (Maybe a)
go Maybe a
Nothing t m a
m1 =
let stop :: m (Maybe a)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
single :: a -> m (Maybe a)
single a
a = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
a)
yieldk :: a -> t m a -> m (Maybe a)
yieldk a
a t m a
r = Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
a) t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m (Maybe a)
yieldk forall {m :: * -> *} {a}. Monad m => a -> m (Maybe a)
single forall {a}. m (Maybe a)
stop t m a
m1
go (Just a
res) t m a
m1 =
let stop :: m (Maybe a)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
res)
single :: a -> m (Maybe a)
single a
a =
if a
res forall a. Ord a => a -> a -> Bool
<= a
a
then forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
a)
else forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
res)
yieldk :: a -> t m a -> m (Maybe a)
yieldk a
a t m a
r =
if a
res forall a. Ord a => a -> a -> Bool
<= a
a
then Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
a) t m a
r
else Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
res) t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m (Maybe a)
yieldk forall {m :: * -> *}. Monad m => a -> m (Maybe a)
single m (Maybe a)
stop t m a
m1
{-# INLINE maximumBy #-}
maximumBy :: (IsStream t, Monad m) => (a -> a -> Ordering) -> t m a -> m (Maybe a)
maximumBy :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(a -> a -> Ordering) -> t m a -> m (Maybe a)
maximumBy a -> a -> Ordering
cmp t m a
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
(IsStream t, Monad m) =>
Maybe a -> t m a -> m (Maybe a)
go forall a. Maybe a
Nothing t m a
m
where
go :: Maybe a -> t m a -> m (Maybe a)
go Maybe a
Nothing t m a
m1 =
let stop :: m (Maybe a)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
single :: a -> m (Maybe a)
single a
a = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
a)
yieldk :: a -> t m a -> m (Maybe a)
yieldk a
a t m a
r = Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
a) t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m (Maybe a)
yieldk forall {m :: * -> *} {a}. Monad m => a -> m (Maybe a)
single forall {a}. m (Maybe a)
stop t m a
m1
go (Just a
res) t m a
m1 =
let stop :: m (Maybe a)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
res)
single :: a -> m (Maybe a)
single a
a = case a -> a -> Ordering
cmp a
res a
a of
Ordering
GT -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
res)
Ordering
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just a
a)
yieldk :: a -> t m a -> m (Maybe a)
yieldk a
a t m a
r = case a -> a -> Ordering
cmp a
res a
a of
Ordering
GT -> Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
res) t m a
r
Ordering
_ -> Maybe a -> t m a -> m (Maybe a)
go (forall a. a -> Maybe a
Just a
a) t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m (Maybe a)
yieldk forall {m :: * -> *}. Monad m => a -> m (Maybe a)
single m (Maybe a)
stop t m a
m1
{-# INLINE (!!) #-}
(!!) :: (IsStream t, Monad m) => t m a -> Int -> m (Maybe a)
t m a
m !! :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> Int -> m (Maybe a)
!! Int
i = forall {t :: (* -> *) -> * -> *} {m :: * -> *} {t} {a}.
(IsStream t, Ord t, Monad m, Num t) =>
t -> t m a -> m (Maybe a)
go Int
i t m a
m
where
go :: t -> t m a -> m (Maybe a)
go t
n t m a
m1 =
let single :: a -> m (Maybe a)
single a
a | t
n forall a. Eq a => a -> a -> Bool
== t
0 = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just a
a
| Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
yieldk :: a -> t m a -> m (Maybe a)
yieldk a
a t m a
x | t
n forall a. Ord a => a -> a -> Bool
< t
0 = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
| t
n forall a. Eq a => a -> a -> Bool
== t
0 = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just a
a
| Bool
otherwise = t -> t m a -> m (Maybe a)
go (t
n forall a. Num a => a -> a -> a
- t
1) t m a
x
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m (Maybe a)
yieldk forall {m :: * -> *} {a}. Monad m => a -> m (Maybe a)
single (forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing) t m a
m1
{-# INLINE lookup #-}
lookup :: (IsStream t, Monad m, Eq a) => a -> t m (a, b) -> m (Maybe b)
lookup :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a b.
(IsStream t, Monad m, Eq a) =>
a -> t m (a, b) -> m (Maybe b)
lookup a
e t m (a, b)
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *} {a}.
(IsStream t, Monad m) =>
t m (a, a) -> m (Maybe a)
go t m (a, b)
m
where
go :: t m (a, a) -> m (Maybe a)
go t m (a, a)
m1 =
let single :: (a, a) -> m (Maybe a)
single (a
a, a
b) | a
a forall a. Eq a => a -> a -> Bool
== a
e = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just a
b
| Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
yieldk :: (a, a) -> t m (a, a) -> m (Maybe a)
yieldk (a
a, a
b) t m (a, a)
x | a
a forall a. Eq a => a -> a -> Bool
== a
e = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just a
b
| Bool
otherwise = t m (a, a) -> m (Maybe a)
go t m (a, a)
x
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState (a, a) -> t m (a, a) -> m (Maybe a)
yieldk forall {m :: * -> *} {a}. Monad m => (a, a) -> m (Maybe a)
single (forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing) t m (a, a)
m1
{-# INLINE findM #-}
findM :: (IsStream t, Monad m) => (a -> m Bool) -> t m a -> m (Maybe a)
findM :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(a -> m Bool) -> t m a -> m (Maybe a)
findM a -> m Bool
p t m a
m = forall {t :: (* -> *) -> * -> *}.
IsStream t =>
t m a -> m (Maybe a)
go t m a
m
where
go :: t m a -> m (Maybe a)
go t m a
m1 =
let single :: a -> m (Maybe a)
single a
a = do
Bool
b <- a -> m Bool
p a
a
if Bool
b then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just a
a else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
yieldk :: a -> t m a -> m (Maybe a)
yieldk a
a t m a
x = do
Bool
b <- a -> m Bool
p a
a
if Bool
b then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just a
a else t m a -> m (Maybe a)
go t m a
x
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m (Maybe a)
yieldk a -> m (Maybe a)
single (forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing) t m a
m1
{-# INLINE find #-}
find :: (IsStream t, Monad m) => (a -> Bool) -> t m a -> m (Maybe a)
find :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(a -> Bool) -> t m a -> m (Maybe a)
find a -> Bool
p = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(a -> m Bool) -> t m a -> m (Maybe a)
findM (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
p)
{-# INLINE findIndices #-}
findIndices :: IsStream t => (a -> Bool) -> t m a -> t m Int
findIndices :: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
(a -> Bool) -> t m a -> t m Int
findIndices a -> Bool
p = forall {t :: (* -> *) -> * -> *} {t :: (* -> *) -> * -> *} {t}
{m :: * -> *}.
(IsStream t, Num t, IsStream t) =>
t -> t m a -> t m t
go Int
0
where
go :: t -> t m a -> t m t
go t
offset t m a
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m t
st t -> t m t -> m r
yld t -> m r
sng m r
stp ->
let single :: a -> m r
single a
a | a -> Bool
p a
a = t -> m r
sng t
offset
| Bool
otherwise = m r
stp
yieldk :: a -> t m a -> m r
yieldk a
a t m a
x | a -> Bool
p a
a = t -> t m t -> m r
yld t
offset forall a b. (a -> b) -> a -> b
$ t -> t m a -> t m t
go (t
offset forall a. Num a => a -> a -> a
+ t
1) t m a
x
| Bool
otherwise = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream m t
st) t -> t m t -> m r
yld t -> m r
sng m r
stp forall a b. (a -> b) -> a -> b
$
t -> t m a -> t m t
go (t
offset forall a. Num a => a -> a -> a
+ t
1) t m a
x
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream m t
st) a -> t m a -> m r
yieldk a -> m r
single m r
stp t m a
m1
{-# INLINE mapM_ #-}
mapM_ :: (IsStream t, Monad m) => (a -> m b) -> t m a -> m ()
mapM_ :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a b.
(IsStream t, Monad m) =>
(a -> m b) -> t m a -> m ()
mapM_ a -> m b
f t m a
m = forall {t :: (* -> *) -> * -> *}. IsStream t => t m a -> m ()
go t m a
m
where
go :: t m a -> m ()
go t m a
m1 =
let stop :: m ()
stop = forall (m :: * -> *) a. Monad m => a -> m a
return ()
single :: a -> m ()
single a
a = forall (f :: * -> *) a. Functor f => f a -> f ()
void (a -> m b
f a
a)
yieldk :: a -> t m a -> m ()
yieldk a
a t m a
r = a -> m b
f a
a forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> t m a -> m ()
go t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m ()
yieldk a -> m ()
single m ()
stop t m a
m1
{-# INLINABLE toList #-}
toList :: (IsStream t, Monad m) => t m a -> m [a]
toList :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m [a]
toList = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a b.
(IsStream t, Monad m) =>
(a -> b -> b) -> b -> t m a -> m b
foldr (:) []
{-# INLINE toStreamK #-}
toStreamK :: Stream m a -> Stream m a
toStreamK :: forall (m :: * -> *) a. Stream m a -> Stream m a
toStreamK = forall a. a -> a
id
{-# INLINE hoist #-}
hoist :: (IsStream t, Monad m, Monad n)
=> (forall x. m x -> n x) -> t m a -> t n a
hoist :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) (n :: * -> *) a.
(IsStream t, Monad m, Monad n) =>
(forall x. m x -> n x) -> t m a -> t n a
hoist forall x. m x -> n x
f t m a
str =
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream n a
st a -> t n a -> n r
yld a -> n r
sng n r
stp ->
let single :: a -> m (n r)
single = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> n r
sng
yieldk :: a -> t m a -> m (n r)
yieldk a
a t m a
s = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ a -> t n a -> n r
yld a
a (forall (t :: (* -> *) -> * -> *) (m :: * -> *) (n :: * -> *) a.
(IsStream t, Monad m, Monad n) =>
(forall x. m x -> n x) -> t m a -> t n a
hoist forall x. m x -> n x
f t m a
s)
stop :: m (n r)
stop = forall (m :: * -> *) a. Monad m => a -> m a
return n r
stp
state :: State Stream n b
state = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream n a
st
in forall (m :: * -> *) a. Monad m => m (m a) -> m a
join forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x. m x -> n x
f forall a b. (a -> b) -> a -> b
$ forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStreamShared forall {n :: * -> *} {b}. State Stream n b
state forall {m :: * -> *}. Monad m => a -> t m a -> m (n r)
yieldk a -> m (n r)
single m (n r)
stop t m a
str
{-# INLINE scanlx' #-}
scanlx' :: IsStream t => (x -> a -> x) -> x -> (x -> b) -> t m a -> t m b
scanlx' :: forall (t :: (* -> *) -> * -> *) x a b (m :: * -> *).
IsStream t =>
(x -> a -> x) -> x -> (x -> b) -> t m a -> t m b
scanlx' x -> a -> x
step x
begin x -> b
done t m a
m =
forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
cons (x -> b
done x
begin) forall a b. (a -> b) -> a -> b
$ forall {t :: (* -> *) -> * -> *} {t :: (* -> *) -> * -> *}
{m :: * -> *}.
(IsStream t, IsStream t) =>
t m a -> x -> t m b
go t m a
m x
begin
where
go :: t m a -> x -> t m b
go t m a
m1 !x
acc = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m b
st b -> t m b -> m r
yld b -> m r
sng m r
stp ->
let single :: a -> m r
single a
a = b -> m r
sng (x -> b
done forall a b. (a -> b) -> a -> b
$ x -> a -> x
step x
acc a
a)
yieldk :: a -> t m a -> m r
yieldk a
a t m a
r =
let s :: x
s = x -> a -> x
step x
acc a
a
in b -> t m b -> m r
yld (x -> b
done x
s) (t m a -> x -> t m b
go t m a
r x
s)
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream m b
st) a -> t m a -> m r
yieldk a -> m r
single m r
stp t m a
m1
{-# INLINE scanl' #-}
scanl' :: IsStream t => (b -> a -> b) -> b -> t m a -> t m b
scanl' :: forall (t :: (* -> *) -> * -> *) b a (m :: * -> *).
IsStream t =>
(b -> a -> b) -> b -> t m a -> t m b
scanl' b -> a -> b
step b
begin = forall (t :: (* -> *) -> * -> *) x a b (m :: * -> *).
IsStream t =>
(x -> a -> x) -> x -> (x -> b) -> t m a -> t m b
scanlx' b -> a -> b
step b
begin forall a. a -> a
id
{-# INLINE filter #-}
filter :: IsStream t => (a -> Bool) -> t m a -> t m a
filter :: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
(a -> Bool) -> t m a -> t m a
filter a -> Bool
p t m a
m = forall {t :: (* -> *) -> * -> *} {t :: (* -> *) -> * -> *}
{m :: * -> *}.
(IsStream t, IsStream t) =>
t m a -> t m a
go t m a
m
where
go :: t m a -> t m a
go t m a
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp ->
let single :: a -> m r
single a
a | a -> Bool
p a
a = a -> m r
sng a
a
| Bool
otherwise = m r
stp
yieldk :: a -> t m a -> m r
yieldk a
a t m a
r | a -> Bool
p a
a = a -> t m a -> m r
yld a
a (t m a -> t m a
go t m a
r)
| Bool
otherwise = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yieldk a -> m r
single m r
stp t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yieldk a -> m r
single m r
stp t m a
m1
{-# INLINE take #-}
take :: IsStream t => Int -> t m a -> t m a
take :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
Int -> t m a -> t m a
take Int
n t m a
m = forall {t :: (* -> *) -> * -> *} {t} {t :: (* -> *) -> * -> *}
{m :: * -> *} {a}.
(IsStream t, Ord t, IsStream t, Num t) =>
t -> t m a -> t m a
go Int
n t m a
m
where
go :: t -> t m a -> t m a
go t
n1 t m a
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp ->
let yieldk :: a -> t m a -> m r
yieldk a
a t m a
r = a -> t m a -> m r
yld a
a (t -> t m a -> t m a
go (t
n1 forall a. Num a => a -> a -> a
- t
1) t m a
r)
in if t
n1 forall a. Ord a => a -> a -> Bool
<= t
0
then m r
stp
else forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yieldk a -> m r
sng m r
stp t m a
m1
{-# INLINE takeWhile #-}
takeWhile :: IsStream t => (a -> Bool) -> t m a -> t m a
takeWhile :: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
(a -> Bool) -> t m a -> t m a
takeWhile a -> Bool
p t m a
m = forall {t :: (* -> *) -> * -> *} {t :: (* -> *) -> * -> *}
{m :: * -> *}.
(IsStream t, IsStream t) =>
t m a -> t m a
go t m a
m
where
go :: t m a -> t m a
go t m a
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp ->
let single :: a -> m r
single a
a | a -> Bool
p a
a = a -> m r
sng a
a
| Bool
otherwise = m r
stp
yieldk :: a -> t m a -> m r
yieldk a
a t m a
r | a -> Bool
p a
a = a -> t m a -> m r
yld a
a (t m a -> t m a
go t m a
r)
| Bool
otherwise = m r
stp
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yieldk a -> m r
single m r
stp t m a
m1
{-# INLINE drop #-}
drop :: IsStream t => Int -> t m a -> t m a
drop :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
Int -> t m a -> t m a
drop Int
n t m a
m = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
Stream m a -> t m a
fromStream forall a b. (a -> b) -> a -> b
$ forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a -> t m a
unShare (forall {t :: (* -> *) -> * -> *} {t} {m :: * -> *} {a}.
(Ord t, IsStream t, Num t) =>
t -> t m a -> t m a
go Int
n (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a -> Stream m a
toStream t m a
m))
where
go :: t -> t m a -> t m a
go t
n1 t m a
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp ->
let single :: p -> m r
single p
_ = m r
stp
yieldk :: p -> t m a -> m r
yieldk p
_ t m a
r = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStreamShared State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp forall a b. (a -> b) -> a -> b
$ t -> t m a -> t m a
go (t
n1 forall a. Num a => a -> a -> a
- t
1) t m a
r
in if t
n1 forall a. Ord a => a -> a -> Bool
<= t
0
then forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStreamShared State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp t m a
m1
else forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStreamShared State Stream m a
st forall {p}. p -> t m a -> m r
yieldk forall {p}. p -> m r
single m r
stp t m a
m1
{-# INLINE dropWhile #-}
dropWhile :: IsStream t => (a -> Bool) -> t m a -> t m a
dropWhile :: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
(a -> Bool) -> t m a -> t m a
dropWhile a -> Bool
p t m a
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
IsStream t =>
t m a -> t m a
go t m a
m
where
go :: t m a -> t m a
go t m a
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp ->
let single :: a -> m r
single a
a | a -> Bool
p a
a = m r
stp
| Bool
otherwise = a -> m r
sng a
a
yieldk :: a -> t m a -> m r
yieldk a
a t m a
r | a -> Bool
p a
a = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yieldk a -> m r
single m r
stp t m a
r
| Bool
otherwise = a -> t m a -> m r
yld a
a t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yieldk a -> m r
single m r
stp t m a
m1
{-# INLINE sequence #-}
sequence :: (IsStream t, MonadAsync m) => t m (m a) -> t m a
sequence :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
t m (m a) -> t m a
sequence t m (m a)
m = forall {t :: (* -> *) -> * -> *} {t :: (* -> *) -> * -> *}
{m :: * -> *} {a}.
(IsStream t, IsStream t, MonadIO m, MonadBaseControl IO m,
MonadThrow m) =>
t m (m a) -> t m a
go t m (m a)
m
where
go :: t m (m a) -> t m a
go t m (m a)
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp ->
let single :: m a -> m r
single m a
ma = m a
ma forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> m r
sng
yieldk :: m a -> t m (m a) -> m r
yieldk m a
ma t m (m a)
r = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStreamShared State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp forall a b. (a -> b) -> a -> b
$ m a
ma forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a -> t m a
|: t m (m a) -> t m a
go t m (m a)
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream m a
st) m a -> t m (m a) -> m r
yieldk m a -> m r
single m r
stp t m (m a)
m1
{-# INLINE intersperseM #-}
intersperseM :: (IsStream t, MonadAsync m) => m a -> t m a -> t m a
intersperseM :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a -> t m a
intersperseM m a
a t m a
m = forall {t :: (* -> *) -> * -> *} {t :: (* -> *) -> * -> *}.
(IsStream t, IsStream t) =>
t m a -> t m a
prependingStart t m a
m
where
prependingStart :: t m a -> t m a
prependingStart t m a
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp ->
let yieldk :: a -> t m a -> m r
yieldk a
i t m a
x = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStreamShared State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return a
i forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a -> t m a
|: forall {t :: (* -> *) -> * -> *} {t :: (* -> *) -> * -> *}.
(IsStream t, IsStream t) =>
t m a -> t m a
go t m a
x
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st forall {t :: (* -> *) -> * -> *}. IsStream t => a -> t m a -> m r
yieldk a -> m r
sng m r
stp t m a
m1
go :: t m a -> t m a
go t m a
m2 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp ->
let single :: a -> m r
single a
i = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStreamShared State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp forall a b. (a -> b) -> a -> b
$ m a
a forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a -> t m a
|: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a
yield a
i
yieldk :: a -> t m a -> m r
yieldk a
i t m a
x = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStreamShared State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp forall a b. (a -> b) -> a -> b
$ m a
a forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a -> t m a
|: forall (m :: * -> *) a. Monad m => a -> m a
return a
i forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a -> t m a
|: t m a -> t m a
go t m a
x
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yieldk a -> m r
single m r
stp t m a
m2
{-# INLINE intersperse #-}
intersperse :: (IsStream t, MonadAsync m) => a -> t m a -> t m a
intersperse :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
a -> t m a -> t m a
intersperse a
a = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, MonadAsync m) =>
m a -> t m a -> t m a
intersperseM (forall (m :: * -> *) a. Monad m => a -> m a
return a
a)
{-# INLINE insertBy #-}
insertBy :: IsStream t => (a -> a -> Ordering) -> a -> t m a -> t m a
insertBy :: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
(a -> a -> Ordering) -> a -> t m a -> t m a
insertBy a -> a -> Ordering
cmp a
x t m a
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
IsStream t =>
t m a -> t m a
go t m a
m
where
go :: t m a -> t m a
go t m a
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
_ m r
_ ->
let single :: a -> m r
single a
a = case a -> a -> Ordering
cmp a
x a
a of
Ordering
GT -> a -> t m a -> m r
yld a
a (forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a
yield a
x)
Ordering
_ -> a -> t m a -> m r
yld a
x (forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a
yield a
a)
stop :: m r
stop = a -> t m a -> m r
yld a
x forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil
yieldk :: a -> t m a -> m r
yieldk a
a t m a
r = case a -> a -> Ordering
cmp a
x a
a of
Ordering
GT -> a -> t m a -> m r
yld a
a (t m a -> t m a
go t m a
r)
Ordering
_ -> a -> t m a -> m r
yld a
x (a
a forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
`cons` t m a
r)
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yieldk a -> m r
single m r
stop t m a
m1
{-# INLINE deleteBy #-}
deleteBy :: IsStream t => (a -> a -> Bool) -> a -> t m a -> t m a
deleteBy :: forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
(a -> a -> Bool) -> a -> t m a -> t m a
deleteBy a -> a -> Bool
eq a
x t m a
m = forall {t :: (* -> *) -> * -> *} {m :: * -> *}.
IsStream t =>
t m a -> t m a
go t m a
m
where
go :: t m a -> t m a
go t m a
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp ->
let single :: a -> m r
single a
a = if a -> a -> Bool
eq a
x a
a then m r
stp else a -> m r
sng a
a
yieldk :: a -> t m a -> m r
yieldk a
a t m a
r = if a -> a -> Bool
eq a
x a
a
then forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp t m a
r
else a -> t m a -> m r
yld a
a (t m a -> t m a
go t m a
r)
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yieldk a -> m r
single m r
stp t m a
m1
{-# INLINE reverse #-}
reverse :: IsStream t => t m a -> t m a
reverse :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a -> t m a
reverse = forall (t :: (* -> *) -> * -> *) (m :: * -> *) b a.
IsStream t =>
(t m b -> a -> t m b) -> t m b -> t m a -> t m b
foldlS (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
cons) forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil
{-# INLINE mapMaybe #-}
mapMaybe :: IsStream t => (a -> Maybe b) -> t m a -> t m b
mapMaybe :: forall (t :: (* -> *) -> * -> *) a b (m :: * -> *).
IsStream t =>
(a -> Maybe b) -> t m a -> t m b
mapMaybe a -> Maybe b
f t m a
m = forall {t :: (* -> *) -> * -> *} {t :: (* -> *) -> * -> *}
{m :: * -> *}.
(IsStream t, IsStream t) =>
t m a -> t m b
go t m a
m
where
go :: t m a -> t m b
go t m a
m1 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m b
st b -> t m b -> m r
yld b -> m r
sng m r
stp ->
let single :: a -> m r
single a
a = case a -> Maybe b
f a
a of
Just b
b -> b -> m r
sng b
b
Maybe b
Nothing -> m r
stp
yieldk :: a -> t m a -> m r
yieldk a
a t m a
r = case a -> Maybe b
f a
a of
Just b
b -> b -> t m b -> m r
yld b
b forall a b. (a -> b) -> a -> b
$ t m a -> t m b
go t m a
r
Maybe b
Nothing -> forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream m b
st) a -> t m a -> m r
yieldk a -> m r
single m r
stp t m a
r
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream m b
st) a -> t m a -> m r
yieldk a -> m r
single m r
stp t m a
m1
{-# INLINABLE zipWith #-}
zipWith :: IsStream t => (a -> b -> c) -> t m a -> t m b -> t m c
zipWith :: forall (t :: (* -> *) -> * -> *) a b c (m :: * -> *).
IsStream t =>
(a -> b -> c) -> t m a -> t m b -> t m c
zipWith a -> b -> c
f = forall {t :: (* -> *) -> * -> *} {t :: (* -> *) -> * -> *}
{t :: (* -> *) -> * -> *} {m :: * -> *}.
(IsStream t, IsStream t, IsStream t) =>
t m a -> t m b -> t m c
go
where
go :: t m a -> t m b -> t m c
go t m a
mx t m b
my = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m c
st c -> t m c -> m r
yld c -> m r
sng m r
stp -> do
let merge :: a -> t m a -> m r
merge a
a t m a
ra =
let single2 :: b -> m r
single2 b
b = c -> m r
sng (a -> b -> c
f a
a b
b)
yield2 :: b -> t m b -> m r
yield2 b
b t m b
rb = c -> t m c -> m r
yld (a -> b -> c
f a
a b
b) (t m a -> t m b -> t m c
go t m a
ra t m b
rb)
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream m c
st) b -> t m b -> m r
yield2 b -> m r
single2 m r
stp t m b
my
let single1 :: a -> m r
single1 a
a = a -> t m a -> m r
merge a
a forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil
yield1 :: a -> t m a -> m r
yield1 = a -> t m a -> m r
merge
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream m c
st) a -> t m a -> m r
yield1 a -> m r
single1 m r
stp t m a
mx
{-# INLINABLE zipWithM #-}
zipWithM :: (IsStream t, Monad m) => (a -> b -> m c) -> t m a -> t m b -> t m c
zipWithM :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a b c.
(IsStream t, Monad m) =>
(a -> b -> m c) -> t m a -> t m b -> t m c
zipWithM a -> b -> m c
f t m a
m1 t m b
m2 = forall {t :: (* -> *) -> * -> *} {t :: (* -> *) -> * -> *}
{t :: (* -> *) -> * -> *}.
(IsStream t, IsStream t, IsStream t) =>
t m a -> t m b -> t m c
go t m a
m1 t m b
m2
where
go :: t m a -> t m b -> t m c
go t m a
mx t m b
my = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m c
st c -> t m c -> m r
yld c -> m r
sng m r
stp -> do
let merge :: a -> t m a -> m r
merge a
a t m a
ra =
let runIt :: t m c -> m r
runIt t m c
x = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m c
st c -> t m c -> m r
yld c -> m r
sng m r
stp t m c
x
single2 :: b -> m r
single2 b
b = a -> b -> m c
f a
a b
b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= c -> m r
sng
yield2 :: b -> t m b -> m r
yield2 b
b t m b
rb = a -> b -> m c
f a
a b
b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \c
x -> t m c -> m r
runIt (c
x forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
`cons` t m a -> t m b -> t m c
go t m a
ra t m b
rb)
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream m c
st) b -> t m b -> m r
yield2 b -> m r
single2 m r
stp t m b
my
let single1 :: a -> m r
single1 a
a = a -> t m a -> m r
merge a
a forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil
yield1 :: a -> t m a -> m r
yield1 = a -> t m a -> m r
merge
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a (n :: * -> *) b.
State t m a -> State t n b
adaptState State Stream m c
st) a -> t m a -> m r
yield1 a -> m r
single1 m r
stp t m a
mx
{-# INLINE mergeByM #-}
mergeByM
:: (IsStream t, Monad m)
=> (a -> a -> m Ordering) -> t m a -> t m a -> t m a
mergeByM :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(a -> a -> m Ordering) -> t m a -> t m a -> t m a
mergeByM a -> a -> m Ordering
cmp = forall {t :: (* -> *) -> * -> *}.
IsStream t =>
t m a -> t m a -> t m a
go
where
go :: t m a -> t m a -> t m a
go t m a
mx t m a
my = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp -> do
let mergeWithY :: a -> t m a -> m r
mergeWithY a
a t m a
ra =
let stop2 :: m r
stop2 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp t m a
mx
single2 :: a -> m r
single2 a
b = do
Ordering
r <- a -> a -> m Ordering
cmp a
a a
b
case Ordering
r of
Ordering
GT -> a -> t m a -> m r
yld a
b (t m a -> t m a -> t m a
go (a
a forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
`cons` t m a
ra) forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil)
Ordering
_ -> a -> t m a -> m r
yld a
a (t m a -> t m a -> t m a
go t m a
ra (a
b forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
`cons` forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil))
yield2 :: a -> t m a -> m r
yield2 a
b t m a
rb = do
Ordering
r <- a -> a -> m Ordering
cmp a
a a
b
case Ordering
r of
Ordering
GT -> a -> t m a -> m r
yld a
b (t m a -> t m a -> t m a
go (a
a forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
`cons` t m a
ra) t m a
rb)
Ordering
_ -> a -> t m a -> m r
yld a
a (t m a -> t m a -> t m a
go t m a
ra (a
b forall (t :: (* -> *) -> * -> *) a (m :: * -> *).
IsStream t =>
a -> t m a -> t m a
`cons` t m a
rb))
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yield2 a -> m r
single2 m r
stop2 t m a
my
let stopX :: m r
stopX = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yld a -> m r
sng m r
stp t m a
my
singleX :: a -> m r
singleX a
a = a -> t m a -> m r
mergeWithY a
a forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
t m a
nil
yieldX :: a -> t m a -> m r
yieldX = a -> t m a -> m r
mergeWithY
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> t m a -> m r
yieldX a -> m r
singleX m r
stopX t m a
mx
{-# INLINABLE mergeBy #-}
mergeBy
:: (IsStream t, Monad m)
=> (a -> a -> Ordering) -> t m a -> t m a -> t m a
mergeBy :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(a -> a -> Ordering) -> t m a -> t m a -> t m a
mergeBy a -> a -> Ordering
cmp = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
(a -> a -> m Ordering) -> t m a -> t m a -> t m a
mergeByM (\a
a a
b -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ a -> a -> Ordering
cmp a
a a
b)
{-# INLINE the #-}
the :: (Eq a, IsStream t, Monad m) => t m a -> m (Maybe a)
the :: forall a (t :: (* -> *) -> * -> *) (m :: * -> *).
(Eq a, IsStream t, Monad m) =>
t m a -> m (Maybe a)
the t m a
m = do
Maybe (a, t m a)
r <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(IsStream t, Monad m) =>
t m a -> m (Maybe (a, t m a))
uncons t m a
m
case Maybe (a, t m a)
r of
Maybe (a, t m a)
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
Just (a
h, t m a
t) -> forall {t :: (* -> *) -> * -> *} {m :: * -> *} {a}.
(IsStream t, Monad m, Eq a) =>
a -> t m a -> m (Maybe a)
go a
h t m a
t
where
go :: a -> t m a -> m (Maybe a)
go a
h t m a
m1 =
let single :: a -> m (Maybe a)
single a
a | a
h forall a. Eq a => a -> a -> Bool
== a
a = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just a
h
| Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
yieldk :: a -> t m a -> m (Maybe a)
yieldk a
a t m a
r | a
h forall a. Eq a => a -> a -> Bool
== a
a = a -> t m a -> m (Maybe a)
go a
h t m a
r
| Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. State t m a
defState a -> t m a -> m (Maybe a)
yieldk forall {m :: * -> *}. Monad m => a -> m (Maybe a)
single (forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just a
h) t m a
m1
_alt :: Stream m a -> Stream m a -> Stream m a
_alt :: forall (m :: * -> *) a. Stream m a -> Stream m a -> Stream m a
_alt Stream m a
m1 Stream m a
m2 = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> Stream m a -> m r
yld a -> m r
sng m r
stp ->
let stop :: m r
stop = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> Stream m a -> m r
yld a -> m r
sng m r
stp Stream m a
m2
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> Stream m a -> m r
yld a -> m r
sng m r
stop Stream m a
m1
{-# INLINABLE withLocal #-}
withLocal :: MonadReader r m => (r -> r) -> Stream m a -> Stream m a
withLocal :: forall r (m :: * -> *) a.
MonadReader r m =>
(r -> r) -> Stream m a -> Stream m a
withLocal r -> r
f Stream m a
m =
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
IsStream t =>
(forall r.
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> m r)
-> t m a
mkStream forall a b. (a -> b) -> a -> b
$ \State Stream m a
st a -> Stream m a -> m r
yld a -> m r
sng m r
stp ->
let single :: a -> m r
single = forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r -> r
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m r
sng
yieldk :: a -> Stream m a -> m r
yieldk a
a Stream m a
r = forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r -> r
f forall a b. (a -> b) -> a -> b
$ a -> Stream m a -> m r
yld a
a (forall r (m :: * -> *) a.
MonadReader r m =>
(r -> r) -> Stream m a -> Stream m a
withLocal r -> r
f Stream m a
r)
in forall (t :: (* -> *) -> * -> *) (m :: * -> *) a r.
IsStream t =>
State Stream m a
-> (a -> t m a -> m r) -> (a -> m r) -> m r -> t m a -> m r
foldStream State Stream m a
st a -> Stream m a -> m r
yieldk a -> m r
single (forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r -> r
f m r
stp) Stream m a
m