{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Streamly.Internal.Data.Fold
(
Fold (..)
, hoist
, generally
, mkPure
, mkPureId
, mkFold
, mkFoldId
, drain
, drainBy
, drainBy2
, last
, length
, sum
, product
, maximumBy
, maximum
, minimumBy
, minimum
, mean
, variance
, stdDev
, rollingHash
, rollingHashWithSalt
, rollingHashFirstN
, mconcat
, foldMap
, foldMapM
, toList
, toListRevF
, drainN
, drainWhile
, index
, head
, find
, lookup
, findIndex
, elemIndex
, null
, elem
, notElem
, all
, any
, and
, or
, sequence
, mapM
, transform
, lmap
, lmapM
, lfilter
, lfilterM
, lcatMaybes
, ltake
, ltakeWhile
, lsessionsOf
, lchunksOf
, splitAt
, span
, break
, spanBy
, spanByRolling
, tee
, distribute
, distribute_
, partition
, demux
, demux_
, demuxDefault_
, demuxWithDefault_
, classify
, unzip
, foldChunks
, duplicate
, initialize
, runStep
, toParallelSVar
, toParallelSVarLimited
)
where
import Control.Monad (void)
import Control.Monad.IO.Class (MonadIO(..))
import Data.Functor.Identity (Identity(..))
import Data.Int (Int64)
import Data.Map.Strict (Map)
import Prelude
hiding (filter, drop, dropWhile, take, takeWhile, zipWith, foldr,
foldl, map, mapM_, sequence, all, any, sum, product, elem,
notElem, maximum, minimum, head, last, tail, length, null,
reverse, iterate, init, and, or, lookup, foldr1, (!!),
scanl, scanl1, replicate, concatMap, mconcat, foldMap, unzip,
span, splitAt, break, mapM)
import qualified Data.Map.Strict as Map
import qualified Prelude
import Streamly.Internal.Data.Pipe.Types (Pipe (..), PipeState(..))
import Streamly.Internal.Data.Fold.Types
import Streamly.Internal.Data.Strict
import Streamly.Internal.Data.SVar
import qualified Streamly.Internal.Data.Pipe.Types as Pipe
{-# INLINE mkPure #-}
mkPure :: Monad m => (s -> a -> s) -> s -> (s -> b) -> Fold m a b
mkPure :: forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> s) -> s -> (s -> b) -> Fold m a b
mkPure s -> a -> s
step s
initial s -> b
extract =
forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\s
s a
a -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ s -> a -> s
step s
s a
a) (forall (m :: * -> *) a. Monad m => a -> m a
return s
initial) (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> b
extract)
{-# INLINE mkPureId #-}
mkPureId :: Monad m => (b -> a -> b) -> b -> Fold m a b
mkPureId :: forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Fold m a b
mkPureId b -> a -> b
step b
initial = forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> s) -> s -> (s -> b) -> Fold m a b
mkPure b -> a -> b
step b
initial forall a. a -> a
id
{-# INLINE mkFold #-}
mkFold :: (s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
mkFold :: forall s a (m :: * -> *) b.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
mkFold = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold
{-# INLINE mkFoldId #-}
mkFoldId :: Monad m => (b -> a -> m b) -> m b -> Fold m a b
mkFoldId :: forall (m :: * -> *) b a.
Monad m =>
(b -> a -> m b) -> m b -> Fold m a b
mkFoldId b -> a -> m b
step m b
initial = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold b -> a -> m b
step m b
initial forall (m :: * -> *) a. Monad m => a -> m a
return
hoist :: (forall x. m x -> n x) -> Fold m a b -> Fold n a b
hoist :: forall (m :: * -> *) (n :: * -> *) a b.
(forall x. m x -> n x) -> Fold m a b -> Fold n a b
hoist forall x. m x -> n x
f (Fold s -> a -> m s
step m s
initial s -> m b
extract) =
forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\s
x a
a -> forall x. m x -> n x
f forall a b. (a -> b) -> a -> b
$ s -> a -> m s
step s
x a
a) (forall x. m x -> n x
f m s
initial) (forall x. m x -> n x
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> m b
extract)
generally :: Monad m => Fold Identity a b -> Fold m a b
generally :: forall (m :: * -> *) a b.
Monad m =>
Fold Identity a b -> Fold m a b
generally = forall (m :: * -> *) (n :: * -> *) a b.
(forall x. m x -> n x) -> Fold m a b -> Fold n a b
hoist (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Identity a -> a
runIdentity)
{-# INLINE sequence #-}
sequence :: Monad m => Fold m a (m b) -> Fold m a b
sequence :: forall (m :: * -> *) a b. Monad m => Fold m a (m b) -> Fold m a b
sequence (Fold s -> a -> m s
step m s
initial s -> m (m b)
extract) = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold s -> a -> m s
step m s
initial s -> m b
extract'
where
extract' :: s -> m b
extract' s
x = do
m b
act <- s -> m (m b)
extract s
x
m b
act forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINE mapM #-}
mapM :: Monad m => (b -> m c) -> Fold m a b -> Fold m a c
mapM :: forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> Fold m a b -> Fold m a c
mapM b -> m c
f = forall (m :: * -> *) a b. Monad m => Fold m a (m b) -> Fold m a b
sequence forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> m c
f
{-# INLINE transform #-}
transform :: Monad m => Pipe m a b -> Fold m b c -> Fold m a c
transform :: forall (m :: * -> *) a b c.
Monad m =>
Pipe m a b -> Fold m b c -> Fold m a c
transform (Pipe s1 -> a -> m (Step (PipeState s1 s2) b)
pstep1 s2 -> m (Step (PipeState s1 s2) b)
pstep2 s1
pinitial) (Fold s -> b -> m s
fstep m s
finitial s -> m c
fextract) =
forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold Tuple' s1 s -> a -> m (Tuple' s1 s)
step m (Tuple' s1 s)
initial forall {a}. Tuple' a s -> m c
extract
where
initial :: m (Tuple' s1 s)
initial = forall a b. a -> b -> Tuple' a b
Tuple' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. Monad m => a -> m a
return s1
pinitial forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m s
finitial
step :: Tuple' s1 s -> a -> m (Tuple' s1 s)
step (Tuple' s1
ps s
fs) a
x = do
Step (PipeState s1 s2) b
r <- s1 -> a -> m (Step (PipeState s1 s2) b)
pstep1 s1
ps a
x
s -> Step (PipeState s1 s2) b -> m (Tuple' s1 s)
go s
fs Step (PipeState s1 s2) b
r
where
go :: s -> Step (PipeState s1 s2) b -> m (Tuple' s1 s)
go s
acc (Pipe.Yield b
b (Consume s1
ps')) = do
s
acc' <- s -> b -> m s
fstep s
acc b
b
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> b -> Tuple' a b
Tuple' s1
ps' s
acc')
go s
acc (Pipe.Yield b
b (Produce s2
ps')) = do
s
acc' <- s -> b -> m s
fstep s
acc b
b
Step (PipeState s1 s2) b
r <- s2 -> m (Step (PipeState s1 s2) b)
pstep2 s2
ps'
s -> Step (PipeState s1 s2) b -> m (Tuple' s1 s)
go s
acc' Step (PipeState s1 s2) b
r
go s
acc (Pipe.Continue (Consume s1
ps')) = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> b -> Tuple' a b
Tuple' s1
ps' s
acc)
go s
acc (Pipe.Continue (Produce s2
ps')) = do
Step (PipeState s1 s2) b
r <- s2 -> m (Step (PipeState s1 s2) b)
pstep2 s2
ps'
s -> Step (PipeState s1 s2) b -> m (Tuple' s1 s)
go s
acc Step (PipeState s1 s2) b
r
extract :: Tuple' a s -> m c
extract (Tuple' a
_ s
fs) = s -> m c
fextract s
fs
{-# INLINABLE _Fold1 #-}
_Fold1 :: Monad m => (a -> a -> a) -> Fold m a (Maybe a)
_Fold1 :: forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Fold m a (Maybe a)
_Fold1 a -> a -> a
step = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *}. Monad m => Maybe' a -> a -> m (Maybe' a)
step_ (forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe' a
Nothing') (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Maybe' a -> Maybe a
toMaybe)
where
step_ :: Maybe' a -> a -> m (Maybe' a)
step_ Maybe' a
mx a
a = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe' a
Just' forall a b. (a -> b) -> a -> b
$
case Maybe' a
mx of
Maybe' a
Nothing' -> a
a
Just' a
x -> a -> a -> a
step a
x a
a
{-# INLINABLE drain #-}
drain :: Monad m => Fold m a ()
drain :: forall (m :: * -> *) a. Monad m => Fold m a ()
drain = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *} {p} {p}. Monad m => p -> p -> m ()
step m ()
begin forall {a}. a -> m a
done
where
begin :: m ()
begin = forall (m :: * -> *) a. Monad m => a -> m a
return ()
step :: p -> p -> m ()
step p
_ p
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ()
done :: a -> m a
done = forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINABLE drainBy #-}
drainBy :: Monad m => (a -> m b) -> Fold m a ()
drainBy :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Fold m a ()
drainBy a -> m b
f = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (forall a b. a -> b -> a
const (forall (f :: * -> *) a. Functor f => f a -> f ()
void forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m b
f)) (forall (m :: * -> *) a. Monad m => a -> m a
return ()) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINABLE drainBy2 #-}
drainBy2 :: Monad m => (a -> m b) -> Fold2 m c a ()
drainBy2 :: forall (m :: * -> *) a b c. Monad m => (a -> m b) -> Fold2 m c a ()
drainBy2 a -> m b
f = forall (m :: * -> *) c a b s.
(s -> a -> m s) -> (c -> m s) -> (s -> m b) -> Fold2 m c a b
Fold2 (forall a b. a -> b -> a
const (forall (f :: * -> *) a. Functor f => f a -> f ()
void forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m b
f)) (\c
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ()) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINABLE last #-}
last :: Monad m => Fold m a (Maybe a)
last :: forall (m :: * -> *) a. Monad m => Fold m a (Maybe a)
last = forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Fold m a (Maybe a)
_Fold1 (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. a -> b -> a
const)
{-# INLINABLE genericLength #-}
genericLength :: (Monad m, Num b) => Fold m a b
genericLength :: forall (m :: * -> *) b a. (Monad m, Num b) => Fold m a b
genericLength = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\b
n a
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ b
n forall a. Num a => a -> a -> a
+ b
1) (forall (m :: * -> *) a. Monad m => a -> m a
return b
0) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINABLE length #-}
length :: Monad m => Fold m a Int
length :: forall (m :: * -> *) a. Monad m => Fold m a Int
length = forall (m :: * -> *) b a. (Monad m, Num b) => Fold m a b
genericLength
{-# INLINABLE sum #-}
sum :: (Monad m, Num a) => Fold m a a
sum :: forall (m :: * -> *) a. (Monad m, Num a) => Fold m a a
sum = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\a
x a
a -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ a
x forall a. Num a => a -> a -> a
+ a
a) (forall (m :: * -> *) a. Monad m => a -> m a
return a
0) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINABLE product #-}
product :: (Monad m, Num a) => Fold m a a
product :: forall (m :: * -> *) a. (Monad m, Num a) => Fold m a a
product = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\a
x a
a -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ a
x forall a. Num a => a -> a -> a
* a
a) (forall (m :: * -> *) a. Monad m => a -> m a
return a
1) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINABLE maximumBy #-}
maximumBy :: Monad m => (a -> a -> Ordering) -> Fold m a (Maybe a)
maximumBy :: forall (m :: * -> *) a.
Monad m =>
(a -> a -> Ordering) -> Fold m a (Maybe a)
maximumBy a -> a -> Ordering
cmp = forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Fold m a (Maybe a)
_Fold1 a -> a -> a
max'
where
max' :: a -> a -> a
max' a
x a
y = case a -> a -> Ordering
cmp a
x a
y of
Ordering
GT -> a
x
Ordering
_ -> a
y
{-# INLINABLE maximum #-}
maximum :: (Monad m, Ord a) => Fold m a (Maybe a)
maximum :: forall (m :: * -> *) a. (Monad m, Ord a) => Fold m a (Maybe a)
maximum = forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Fold m a (Maybe a)
_Fold1 forall a. Ord a => a -> a -> a
max
{-# INLINABLE minimumBy #-}
minimumBy :: Monad m => (a -> a -> Ordering) -> Fold m a (Maybe a)
minimumBy :: forall (m :: * -> *) a.
Monad m =>
(a -> a -> Ordering) -> Fold m a (Maybe a)
minimumBy a -> a -> Ordering
cmp = forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Fold m a (Maybe a)
_Fold1 a -> a -> a
min'
where
min' :: a -> a -> a
min' a
x a
y = case a -> a -> Ordering
cmp a
x a
y of
Ordering
GT -> a
y
Ordering
_ -> a
x
{-# INLINABLE minimum #-}
minimum :: (Monad m, Ord a) => Fold m a (Maybe a)
minimum :: forall (m :: * -> *) a. (Monad m, Ord a) => Fold m a (Maybe a)
minimum = forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Fold m a (Maybe a)
_Fold1 forall a. Ord a => a -> a -> a
min
{-# INLINABLE mean #-}
mean :: (Monad m, Fractional a) => Fold m a a
mean :: forall (m :: * -> *) a. (Monad m, Fractional a) => Fold m a a
mean = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *} {b}.
(Monad m, Fractional b) =>
Tuple' b b -> b -> m (Tuple' b b)
step (forall (m :: * -> *) a. Monad m => a -> m a
return Tuple' a a
begin) (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a} {b}. Tuple' a b -> a
done)
where
begin :: Tuple' a a
begin = forall a b. a -> b -> Tuple' a b
Tuple' a
0 a
0
step :: Tuple' b b -> b -> m (Tuple' b b)
step (Tuple' b
x b
n) b
y = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
let n' :: b
n' = b
n forall a. Num a => a -> a -> a
+ b
1
in forall a b. a -> b -> Tuple' a b
Tuple' (b
x forall a. Num a => a -> a -> a
+ (b
y forall a. Num a => a -> a -> a
- b
x) forall a. Fractional a => a -> a -> a
/ b
n') b
n'
done :: Tuple' a b -> a
done (Tuple' a
x b
_) = a
x
{-# INLINABLE variance #-}
variance :: (Monad m, Fractional a) => Fold m a a
variance :: forall (m :: * -> *) a. (Monad m, Fractional a) => Fold m a a
variance = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *} {c}.
(Monad m, Fractional c) =>
Tuple3' c c c -> c -> m (Tuple3' c c c)
step (forall (m :: * -> *) a. Monad m => a -> m a
return Tuple3' a a a
begin) (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a} {b}. Fractional a => Tuple3' a b a -> a
done)
where
begin :: Tuple3' a a a
begin = forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' a
0 a
0 a
0
step :: Tuple3' c c c -> c -> m (Tuple3' c c c)
step (Tuple3' c
n c
mean_ c
m2) c
x = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' c
n' c
mean' c
m2'
where
n' :: c
n' = c
n forall a. Num a => a -> a -> a
+ c
1
mean' :: c
mean' = (c
n forall a. Num a => a -> a -> a
* c
mean_ forall a. Num a => a -> a -> a
+ c
x) forall a. Fractional a => a -> a -> a
/ (c
n forall a. Num a => a -> a -> a
+ c
1)
delta :: c
delta = c
x forall a. Num a => a -> a -> a
- c
mean_
m2' :: c
m2' = c
m2 forall a. Num a => a -> a -> a
+ c
delta forall a. Num a => a -> a -> a
* c
delta forall a. Num a => a -> a -> a
* c
n forall a. Fractional a => a -> a -> a
/ (c
n forall a. Num a => a -> a -> a
+ c
1)
done :: Tuple3' a b a -> a
done (Tuple3' a
n b
_ a
m2) = a
m2 forall a. Fractional a => a -> a -> a
/ a
n
{-# INLINABLE stdDev #-}
stdDev :: (Monad m, Floating a) => Fold m a a
stdDev :: forall (m :: * -> *) a. (Monad m, Floating a) => Fold m a a
stdDev = forall a. Floating a => a -> a
sqrt forall (m :: * -> *) a. (Monad m, Fractional a) => Fold m a a
variance
{-# INLINABLE rollingHashWithSalt #-}
rollingHashWithSalt :: (Monad m, Enum a) => Int64 -> Fold m a Int64
rollingHashWithSalt :: forall (m :: * -> *) a.
(Monad m, Enum a) =>
Int64 -> Fold m a Int64
rollingHashWithSalt Int64
salt = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *} {a}.
(Monad m, Enum a) =>
Int64 -> a -> m Int64
step m Int64
initial forall {a}. a -> m a
extract
where
k :: Int64
k = Int64
2891336453 :: Int64
initial :: m Int64
initial = forall (m :: * -> *) a. Monad m => a -> m a
return Int64
salt
step :: Int64 -> a -> m Int64
step Int64
cksum a
a = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int64
cksum forall a. Num a => a -> a -> a
* Int64
k forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral (forall a. Enum a => a -> Int
fromEnum a
a)
extract :: a -> m a
extract = forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINE defaultSalt #-}
defaultSalt :: Int64
defaultSalt :: Int64
defaultSalt = -Int64
2578643520546668380
{-# INLINABLE rollingHash #-}
rollingHash :: (Monad m, Enum a) => Fold m a Int64
rollingHash :: forall (m :: * -> *) a. (Monad m, Enum a) => Fold m a Int64
rollingHash = forall (m :: * -> *) a.
(Monad m, Enum a) =>
Int64 -> Fold m a Int64
rollingHashWithSalt Int64
defaultSalt
{-# INLINABLE rollingHashFirstN #-}
rollingHashFirstN :: (Monad m, Enum a) => Int -> Fold m a Int64
rollingHashFirstN :: forall (m :: * -> *) a. (Monad m, Enum a) => Int -> Fold m a Int64
rollingHashFirstN Int
n = forall (m :: * -> *) a b.
Monad m =>
Int -> Fold m a b -> Fold m a b
ltake Int
n forall (m :: * -> *) a. (Monad m, Enum a) => Fold m a Int64
rollingHash
{-# INLINABLE mconcat #-}
mconcat :: (Monad m, Monoid a) => Fold m a a
mconcat :: forall (m :: * -> *) a. (Monad m, Monoid a) => Fold m a a
mconcat = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\a
x a
a -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. Monoid a => a -> a -> a
mappend a
x a
a) (forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Monoid a => a
mempty) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINABLE foldMap #-}
foldMap :: (Monad m, Monoid b) => (a -> b) -> Fold m a b
foldMap :: forall (m :: * -> *) b a.
(Monad m, Monoid b) =>
(a -> b) -> Fold m a b
foldMap a -> b
f = forall a b (m :: * -> *) r. (a -> b) -> Fold m b r -> Fold m a r
lmap a -> b
f forall (m :: * -> *) a. (Monad m, Monoid a) => Fold m a a
mconcat
{-# INLINABLE foldMapM #-}
foldMapM :: (Monad m, Monoid b) => (a -> m b) -> Fold m a b
foldMapM :: forall (m :: * -> *) b a.
(Monad m, Monoid b) =>
(a -> m b) -> Fold m a b
foldMapM a -> m b
act = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold b -> a -> m b
step m b
begin forall {a}. a -> m a
done
where
done :: a -> m a
done = forall (m :: * -> *) a. Monad m => a -> m a
return
begin :: m b
begin = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Monoid a => a
mempty
step :: b -> a -> m b
step b
m a
a = do
b
m' <- a -> m b
act a
a
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! forall a. Monoid a => a -> a -> a
mappend b
m b
m'
{-# INLINABLE toList #-}
toList :: Monad m => Fold m a [a]
toList :: forall (m :: * -> *) a. Monad m => Fold m a [a]
toList = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\[a] -> [a]
f a
x -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [a] -> [a]
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a
x forall a. a -> [a] -> [a]
:))
(forall (m :: * -> *) a. Monad m => a -> m a
return forall a. a -> a
id)
(forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (a -> b) -> a -> b
$ []))
{-# INLINABLE drainN #-}
drainN :: Monad m => Int -> Fold m a ()
drainN :: forall (m :: * -> *) a. Monad m => Int -> Fold m a ()
drainN Int
n = forall (m :: * -> *) a b.
Monad m =>
Int -> Fold m a b -> Fold m a b
ltake Int
n forall (m :: * -> *) a. Monad m => Fold m a ()
drain
{-# INLINABLE drainWhile #-}
drainWhile :: Monad m => (a -> Bool) -> Fold m a ()
drainWhile :: forall (m :: * -> *) a. Monad m => (a -> Bool) -> Fold m a ()
drainWhile a -> Bool
p = forall (m :: * -> *) a b.
Monad m =>
(a -> Bool) -> Fold m a b -> Fold m a b
ltakeWhile a -> Bool
p forall (m :: * -> *) a. Monad m => Fold m a ()
drain
{-# INLINABLE genericIndex #-}
genericIndex :: (Integral i, Monad m) => i -> Fold m a (Maybe a)
genericIndex :: forall i (m :: * -> *) a.
(Integral i, Monad m) =>
i -> Fold m a (Maybe a)
genericIndex i
i = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *} {b}.
Monad m =>
Either' i b -> b -> m (Either' i b)
step (forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either' a b
Left' i
0) forall {m :: * -> *} {a} {a}. Monad m => Either' a a -> m (Maybe a)
done
where
step :: Either' i b -> b -> m (Either' i b)
step Either' i b
x b
a = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
case Either' i b
x of
Left' i
j -> if i
i forall a. Eq a => a -> a -> Bool
== i
j
then forall a b. b -> Either' a b
Right' b
a
else forall a b. a -> Either' a b
Left' (i
j forall a. Num a => a -> a -> a
+ i
1)
Either' i b
_ -> Either' i b
x
done :: Either' a a -> m (Maybe a)
done Either' a a
x = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
case Either' a a
x of
Left' a
_ -> forall a. Maybe a
Nothing
Right' a
a -> forall a. a -> Maybe a
Just a
a
{-# INLINABLE index #-}
index :: Monad m => Int -> Fold m a (Maybe a)
index :: forall (m :: * -> *) a. Monad m => Int -> Fold m a (Maybe a)
index = forall i (m :: * -> *) a.
(Integral i, Monad m) =>
i -> Fold m a (Maybe a)
genericIndex
{-# INLINABLE head #-}
head :: Monad m => Fold m a (Maybe a)
head :: forall (m :: * -> *) a. Monad m => Fold m a (Maybe a)
head = forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Fold m a (Maybe a)
_Fold1 forall a b. a -> b -> a
const
{-# INLINABLE find #-}
find :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
find :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Fold m a (Maybe a)
find a -> Bool
predicate = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *}. Monad m => Maybe' a -> a -> m (Maybe' a)
step (forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe' a
Nothing') (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Maybe' a -> Maybe a
toMaybe)
where
step :: Maybe' a -> a -> m (Maybe' a)
step Maybe' a
x a
a = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
case Maybe' a
x of
Maybe' a
Nothing' -> if a -> Bool
predicate a
a
then forall a. a -> Maybe' a
Just' a
a
else forall a. Maybe' a
Nothing'
Maybe' a
_ -> Maybe' a
x
{-# INLINABLE lookup #-}
lookup :: (Eq a, Monad m) => a -> Fold m (a,b) (Maybe b)
lookup :: forall a (m :: * -> *) b.
(Eq a, Monad m) =>
a -> Fold m (a, b) (Maybe b)
lookup a
a0 = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *} {a}.
Monad m =>
Maybe' a -> (a, a) -> m (Maybe' a)
step (forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe' a
Nothing') (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Maybe' a -> Maybe a
toMaybe)
where
step :: Maybe' a -> (a, a) -> m (Maybe' a)
step Maybe' a
x (a
a,a
b) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
case Maybe' a
x of
Maybe' a
Nothing' -> if a
a forall a. Eq a => a -> a -> Bool
== a
a0
then forall a. a -> Maybe' a
Just' a
b
else forall a. Maybe' a
Nothing'
Maybe' a
_ -> Maybe' a
x
{-# INLINABLE hush #-}
hush :: Either' a b -> Maybe b
hush :: forall a b. Either' a b -> Maybe b
hush (Left' a
_) = forall a. Maybe a
Nothing
hush (Right' b
b) = forall a. a -> Maybe a
Just b
b
{-# INLINABLE findIndex #-}
findIndex :: Monad m => (a -> Bool) -> Fold m a (Maybe Int)
findIndex :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Fold m a (Maybe Int)
findIndex a -> Bool
predicate = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *} {a}.
(Monad m, Num a) =>
Either' a a -> a -> m (Either' a a)
step (forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either' a b
Left' Int
0) (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. Either' a b -> Maybe b
hush)
where
step :: Either' a a -> a -> m (Either' a a)
step Either' a a
x a
a = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
case Either' a a
x of
Left' a
i ->
if a -> Bool
predicate a
a
then forall a b. b -> Either' a b
Right' a
i
else forall a b. a -> Either' a b
Left' (a
i forall a. Num a => a -> a -> a
+ a
1)
Either' a a
_ -> Either' a a
x
{-# INLINABLE elemIndex #-}
elemIndex :: (Eq a, Monad m) => a -> Fold m a (Maybe Int)
elemIndex :: forall a (m :: * -> *).
(Eq a, Monad m) =>
a -> Fold m a (Maybe Int)
elemIndex a
a = forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Fold m a (Maybe Int)
findIndex (a
a forall a. Eq a => a -> a -> Bool
==)
{-# INLINABLE null #-}
null :: Monad m => Fold m a Bool
null :: forall (m :: * -> *) a. Monad m => Fold m a Bool
null = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\Bool
_ a
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False) (forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINABLE any #-}
any :: Monad m => (a -> Bool) -> Fold m a Bool
any :: forall (m :: * -> *) a. Monad m => (a -> Bool) -> Fold m a Bool
any a -> Bool
predicate = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\Bool
x a
a -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool
x Bool -> Bool -> Bool
|| a -> Bool
predicate a
a) (forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINABLE elem #-}
elem :: (Eq a, Monad m) => a -> Fold m a Bool
elem :: forall a (m :: * -> *). (Eq a, Monad m) => a -> Fold m a Bool
elem a
a = forall (m :: * -> *) a. Monad m => (a -> Bool) -> Fold m a Bool
any (a
a forall a. Eq a => a -> a -> Bool
==)
{-# INLINABLE all #-}
all :: Monad m => (a -> Bool) -> Fold m a Bool
all :: forall (m :: * -> *) a. Monad m => (a -> Bool) -> Fold m a Bool
all a -> Bool
predicate = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\Bool
x a
a -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool
x Bool -> Bool -> Bool
&& a -> Bool
predicate a
a) (forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINABLE notElem #-}
notElem :: (Eq a, Monad m) => a -> Fold m a Bool
notElem :: forall a (m :: * -> *). (Eq a, Monad m) => a -> Fold m a Bool
notElem a
a = forall (m :: * -> *) a. Monad m => (a -> Bool) -> Fold m a Bool
all (a
a forall a. Eq a => a -> a -> Bool
/=)
{-# INLINABLE and #-}
and :: Monad m => Fold m Bool Bool
and :: forall (m :: * -> *). Monad m => Fold m Bool Bool
and = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\Bool
x Bool
a -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool
x Bool -> Bool -> Bool
&& Bool
a) (forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINABLE or #-}
or :: Monad m => Fold m Bool Bool
or :: forall (m :: * -> *). Monad m => Fold m Bool Bool
or = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold (\Bool
x Bool
a -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Bool
x Bool -> Bool -> Bool
|| Bool
a) (forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False) forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINE splitAt #-}
splitAt
:: Monad m
=> Int
-> Fold m a b
-> Fold m a c
-> Fold m a (b, c)
splitAt :: forall (m :: * -> *) a b c.
Monad m =>
Int -> Fold m a b -> Fold m a c -> Fold m a (b, c)
splitAt Int
n (Fold s -> a -> m s
stepL m s
initialL s -> m b
extractL) (Fold s -> a -> m s
stepR m s
initialR s -> m c
extractR) =
forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {a}.
(Ord a, Num a) =>
Tuple3' a s s -> a -> m (Tuple3' a s s)
step m (Tuple3' Int s s)
initial forall {a}. Tuple3' a s s -> m (b, c)
extract
where
initial :: m (Tuple3' Int s s)
initial = forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. Monad m => a -> m a
return Int
n forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m s
initialL forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m s
initialR
step :: Tuple3' a s s -> a -> m (Tuple3' a s s)
step (Tuple3' a
i s
xL s
xR) a
input =
if a
i forall a. Ord a => a -> a -> Bool
> a
0
then s -> a -> m s
stepL s
xL a
input forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\s
a -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' (a
i forall a. Num a => a -> a -> a
- a
1) s
a s
xR))
else s -> a -> m s
stepR s
xR a
input forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\s
b -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' a
i s
xL s
b))
extract :: Tuple3' a s s -> m (b, c)
extract (Tuple3' a
_ s
a s
b) = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
extractL s
a forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> s -> m c
extractR s
b
spanBy
:: Monad m
=> (a -> a -> Bool)
-> Fold m a b
-> Fold m a c
-> Fold m a (b, c)
spanBy :: forall (m :: * -> *) a b c.
Monad m =>
(a -> a -> Bool) -> Fold m a b -> Fold m a c -> Fold m a (b, c)
spanBy a -> a -> Bool
cmp (Fold s -> a -> m s
stepL m s
initialL s -> m b
extractL) (Fold s -> a -> m s
stepR m s
initialR s -> m c
extractR) =
forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold Tuple3' s s (Tuple' (Maybe a) Bool)
-> a -> m (Tuple3' s s (Tuple' (Maybe a) Bool))
step forall {a}. m (Tuple3' s s (Tuple' (Maybe a) Bool))
initial forall {c}. Tuple3' s s c -> m (b, c)
extract
where
initial :: m (Tuple3' s s (Tuple' (Maybe a) Bool))
initial = forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m s
initialL forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m s
initialR forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> b -> Tuple' a b
Tuple' forall a. Maybe a
Nothing Bool
True)
step :: Tuple3' s s (Tuple' (Maybe a) Bool)
-> a -> m (Tuple3' s s (Tuple' (Maybe a) Bool))
step (Tuple3' s
a s
b (Tuple' (Just a
frst) Bool
isFirstG)) a
input =
if a -> a -> Bool
cmp a
frst a
input Bool -> Bool -> Bool
&& Bool
isFirstG
then s -> a -> m s
stepL s
a a
input
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\s
a' -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' s
a' s
b (forall a b. a -> b -> Tuple' a b
Tuple' (forall a. a -> Maybe a
Just a
frst) Bool
isFirstG)))
else s -> a -> m s
stepR s
b a
input
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\s
a' -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' s
a s
a' (forall a b. a -> b -> Tuple' a b
Tuple' forall a. Maybe a
Nothing Bool
False)))
step (Tuple3' s
a s
b (Tuple' Maybe a
Nothing Bool
isFirstG)) a
input =
if Bool
isFirstG
then s -> a -> m s
stepL s
a a
input
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\s
a' -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' s
a' s
b (forall a b. a -> b -> Tuple' a b
Tuple' (forall a. a -> Maybe a
Just a
input) Bool
isFirstG)))
else s -> a -> m s
stepR s
b a
input
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\s
a' -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' s
a s
a' (forall a b. a -> b -> Tuple' a b
Tuple' forall a. Maybe a
Nothing Bool
False)))
extract :: Tuple3' s s c -> m (b, c)
extract (Tuple3' s
a s
b c
_) = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
extractL s
a forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> s -> m c
extractR s
b
{-# INLINE span #-}
span
:: Monad m
=> (a -> Bool)
-> Fold m a b
-> Fold m a c
-> Fold m a (b, c)
span :: forall (m :: * -> *) a b c.
Monad m =>
(a -> Bool) -> Fold m a b -> Fold m a c -> Fold m a (b, c)
span a -> Bool
p (Fold s -> a -> m s
stepL m s
initialL s -> m b
extractL) (Fold s -> a -> m s
stepR m s
initialR s -> m c
extractR) =
forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold Tuple3' s s Bool -> a -> m (Tuple3' s s Bool)
step m (Tuple3' s s Bool)
initial forall {c}. Tuple3' s s c -> m (b, c)
extract
where
initial :: m (Tuple3' s s Bool)
initial = forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m s
initialL forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m s
initialR forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
step :: Tuple3' s s Bool -> a -> m (Tuple3' s s Bool)
step (Tuple3' s
a s
b Bool
isFirstG) a
input =
if Bool
isFirstG Bool -> Bool -> Bool
&& a -> Bool
p a
input
then s -> a -> m s
stepL s
a a
input forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\s
a' -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' s
a' s
b Bool
True))
else s -> a -> m s
stepR s
b a
input forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\s
a' -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' s
a s
a' Bool
False))
extract :: Tuple3' s s c -> m (b, c)
extract (Tuple3' s
a s
b c
_) = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
extractL s
a forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> s -> m c
extractR s
b
{-# INLINE break #-}
break
:: Monad m
=> (a -> Bool)
-> Fold m a b
-> Fold m a c
-> Fold m a (b, c)
break :: forall (m :: * -> *) a b c.
Monad m =>
(a -> Bool) -> Fold m a b -> Fold m a c -> Fold m a (b, c)
break a -> Bool
p = forall (m :: * -> *) a b c.
Monad m =>
(a -> Bool) -> Fold m a b -> Fold m a c -> Fold m a (b, c)
span (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
p)
{-# INLINE spanByRolling #-}
spanByRolling
:: Monad m
=> (a -> a -> Bool)
-> Fold m a b
-> Fold m a c
-> Fold m a (b, c)
spanByRolling :: forall (m :: * -> *) a b c.
Monad m =>
(a -> a -> Bool) -> Fold m a b -> Fold m a c -> Fold m a (b, c)
spanByRolling a -> a -> Bool
cmp (Fold s -> a -> m s
stepL m s
initialL s -> m b
extractL) (Fold s -> a -> m s
stepR m s
initialR s -> m c
extractR) =
forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold Tuple3' s s (Maybe a) -> a -> m (Tuple3' s s (Maybe a))
step forall {a}. m (Tuple3' s s (Maybe a))
initial forall {c}. Tuple3' s s c -> m (b, c)
extract
where
initial :: m (Tuple3' s s (Maybe a))
initial = forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m s
initialL forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m s
initialR forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
step :: Tuple3' s s (Maybe a) -> a -> m (Tuple3' s s (Maybe a))
step (Tuple3' s
a s
b (Just a
frst)) a
input =
if a -> a -> Bool
cmp a
input a
frst
then s -> a -> m s
stepL s
a a
input forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\s
a' -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' s
a' s
b (forall a. a -> Maybe a
Just a
input)))
else s -> a -> m s
stepR s
b a
input forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\s
b' -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' s
a s
b' (forall a. a -> Maybe a
Just a
input)))
step (Tuple3' s
a s
b Maybe a
Nothing) a
input =
s -> a -> m s
stepL s
a a
input forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\s
a' -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' s
a' s
b (forall a. a -> Maybe a
Just a
input)))
extract :: Tuple3' s s c -> m (b, c)
extract (Tuple3' s
a s
b c
_) = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
extractL s
a forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> s -> m c
extractR s
b
{-# INLINE tee #-}
tee :: Monad m => Fold m a b -> Fold m a c -> Fold m a (b,c)
tee :: forall (m :: * -> *) a b c.
Monad m =>
Fold m a b -> Fold m a c -> Fold m a (b, c)
tee Fold m a b
f1 Fold m a c
f2 = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fold m a b
f1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fold m a c
f2
{-# INLINE foldNil #-}
foldNil :: Monad m => Fold m a [b]
foldNil :: forall (m :: * -> *) a b. Monad m => Fold m a [b]
foldNil = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *} {p} {p} {a}. Monad m => p -> p -> m [a]
step forall {a}. m [a]
begin forall {a}. a -> m a
done where
begin :: m [a]
begin = forall (m :: * -> *) a. Monad m => a -> m a
return []
step :: p -> p -> m [a]
step p
_ p
_ = forall (m :: * -> *) a. Monad m => a -> m a
return []
done :: a -> m a
done = forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINE foldCons #-}
foldCons :: Monad m => Fold m a b -> Fold m a [b] -> Fold m a [b]
foldCons :: forall (m :: * -> *) a b.
Monad m =>
Fold m a b -> Fold m a [b] -> Fold m a [b]
foldCons (Fold s -> a -> m s
stepL m s
beginL s -> m b
doneL) (Fold s -> a -> m s
stepR m s
beginR s -> m [b]
doneR) =
forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold Tuple' s s -> a -> m (Tuple' s s)
step m (Tuple' s s)
begin Tuple' s s -> m [b]
done
where
begin :: m (Tuple' s s)
begin = forall a b. a -> b -> Tuple' a b
Tuple' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m s
beginL forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m s
beginR
step :: Tuple' s s -> a -> m (Tuple' s s)
step (Tuple' s
xL s
xR) a
a = forall a b. a -> b -> Tuple' a b
Tuple' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> a -> m s
stepL s
xL a
a forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> s -> a -> m s
stepR s
xR a
a
done :: Tuple' s s -> m [b]
done (Tuple' s
xL s
xR) = (:) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (s -> m b
doneL s
xL) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (s -> m [b]
doneR s
xR)
{-# INLINE distribute #-}
distribute :: Monad m => [Fold m a b] -> Fold m a [b]
distribute :: forall (m :: * -> *) a b. Monad m => [Fold m a b] -> Fold m a [b]
distribute [] = forall (m :: * -> *) a b. Monad m => Fold m a [b]
foldNil
distribute (Fold m a b
x:[Fold m a b]
xs) = forall (m :: * -> *) a b.
Monad m =>
Fold m a b -> Fold m a [b] -> Fold m a [b]
foldCons Fold m a b
x (forall (m :: * -> *) a b. Monad m => [Fold m a b] -> Fold m a [b]
distribute [Fold m a b]
xs)
{-# INLINE distribute_ #-}
distribute_ :: Monad m => [Fold m a ()] -> Fold m a ()
distribute_ :: forall (m :: * -> *) a. Monad m => [Fold m a ()] -> Fold m a ()
distribute_ [Fold m a ()]
fs = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *} {t :: * -> *} {a} {b}.
(Foldable t, Monad m) =>
t (Fold m a b) -> a -> m (t (Fold m a b))
step m [Fold m a ()]
initial forall {m :: * -> *} {t :: * -> *} {a} {b}.
(Foldable t, Monad m) =>
t (Fold m a b) -> m ()
extract
where
initial :: m [Fold m a ()]
initial = forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
Prelude.mapM (\(Fold s -> a -> m s
s m s
i s -> m ()
e) ->
m s
i forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \s
r -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold s -> a -> m s
s (forall (m :: * -> *) a. Monad m => a -> m a
return s
r) s -> m ()
e)) [Fold m a ()]
fs
step :: t (Fold m a b) -> a -> m (t (Fold m a b))
step t (Fold m a b)
ss a
a = do
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
Prelude.mapM_ (\(Fold s -> a -> m s
s m s
i s -> m b
_) -> m s
i forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \s
r -> s -> a -> m s
s s
r a
a forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()) t (Fold m a b)
ss
forall (m :: * -> *) a. Monad m => a -> m a
return t (Fold m a b)
ss
extract :: t (Fold m a b) -> m ()
extract t (Fold m a b)
ss = do
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
Prelude.mapM_ (\(Fold s -> a -> m s
_ m s
i s -> m b
e) -> m s
i forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \s
r -> s -> m b
e s
r) t (Fold m a b)
ss
forall (m :: * -> *) a. Monad m => a -> m a
return ()
{-# INLINE partitionByM #-}
partitionByM :: Monad m
=> (a -> m (Either b c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
partitionByM :: forall (m :: * -> *) a b c x y.
Monad m =>
(a -> m (Either b c))
-> Fold m b x -> Fold m c y -> Fold m a (x, y)
partitionByM a -> m (Either b c)
f (Fold s -> b -> m s
stepL m s
beginL s -> m x
doneL) (Fold s -> c -> m s
stepR m s
beginR s -> m y
doneR) =
forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold Tuple' s s -> a -> m (Tuple' s s)
step m (Tuple' s s)
begin Tuple' s s -> m (x, y)
done
where
begin :: m (Tuple' s s)
begin = forall a b. a -> b -> Tuple' a b
Tuple' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m s
beginL forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m s
beginR
step :: Tuple' s s -> a -> m (Tuple' s s)
step (Tuple' s
xL s
xR) a
a = do
Either b c
r <- a -> m (Either b c)
f a
a
case Either b c
r of
Left b
b -> forall a b. a -> b -> Tuple' a b
Tuple' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> b -> m s
stepL s
xL b
b forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. Monad m => a -> m a
return s
xR
Right c
c -> forall a b. a -> b -> Tuple' a b
Tuple' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. Monad m => a -> m a
return s
xL forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> s -> c -> m s
stepR s
xR c
c
done :: Tuple' s s -> m (x, y)
done (Tuple' s
xL s
xR) = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m x
doneL s
xL forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> s -> m y
doneR s
xR
{-# INLINE partitionBy #-}
partitionBy :: Monad m
=> (a -> Either b c) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
partitionBy :: forall (m :: * -> *) a b c x y.
Monad m =>
(a -> Either b c) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
partitionBy a -> Either b c
f = forall (m :: * -> *) a b c x y.
Monad m =>
(a -> m (Either b c))
-> Fold m b x -> Fold m c y -> Fold m a (x, y)
partitionByM (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either b c
f)
{-# INLINE partition #-}
partition :: Monad m
=> Fold m b x -> Fold m c y -> Fold m (Either b c) (x, y)
partition :: forall (m :: * -> *) b x c y.
Monad m =>
Fold m b x -> Fold m c y -> Fold m (Either b c) (x, y)
partition = forall (m :: * -> *) a b c x y.
Monad m =>
(a -> Either b c) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
partitionBy forall a. a -> a
id
{-# INLINE demuxWith #-}
demuxWith :: (Monad m, Ord k)
=> (a -> (k, a')) -> Map k (Fold m a' b) -> Fold m a (Map k b)
demuxWith :: forall (m :: * -> *) k a a' b.
(Monad m, Ord k) =>
(a -> (k, a')) -> Map k (Fold m a' b) -> Fold m a (Map k b)
demuxWith a -> (k, a')
f Map k (Fold m a' b)
kv = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {f :: * -> *} {b}.
Monad f =>
Map k (Fold f a' b) -> a -> f (Map k (Fold f a' b))
step m (Map k (Fold m a' b))
initial forall {a} {b}. Map k (Fold m a b) -> m (Map k b)
extract
where
initial :: m (Map k (Fold m a' b))
initial = forall (m :: * -> *) a. Monad m => a -> m a
return Map k (Fold m a' b)
kv
#if MIN_VERSION_containers(0,5,8)
step :: Map k (Fold f a' b) -> a -> f (Map k (Fold f a' b))
step Map k (Fold f a' b)
mp a
a = case a -> (k, a')
f a
a of
(k
k, a'
a') -> forall (f :: * -> *) k a.
(Functor f, Ord k) =>
(Maybe a -> f (Maybe a)) -> k -> Map k a -> f (Map k a)
Map.alterF forall {f :: * -> *} {b}.
Monad f =>
Maybe (Fold f a' b) -> f (Maybe (Fold f a' b))
twiddle k
k Map k (Fold f a' b)
mp
where
twiddle :: Maybe (Fold f a' b) -> f (Maybe (Fold f a' b))
twiddle Maybe (Fold f a' b)
Nothing = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing
twiddle (Just (Fold s -> a' -> f s
step' f s
acc s -> f b
extract')) = do
!s
r <- f s
acc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \s
x -> s -> a' -> f s
step' s
x a'
a'
forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold s -> a' -> f s
step' (forall (m :: * -> *) a. Monad m => a -> m a
return s
r) s -> f b
extract'
#else
step mp a =
let (k, a') = f a
in case Map.lookup k mp of
Nothing -> return mp
Just (Fold step' acc extract') -> do
!r <- acc >>= \x -> step' x a'
return $ Map.insert k (Fold step' (return r) extract') mp
#endif
extract :: Map k (Fold m a b) -> m (Map k b)
extract = forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
Prelude.mapM (\(Fold s -> a -> m s
_ m s
acc s -> m b
e) -> m s
acc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= s -> m b
e)
{-# INLINE demux #-}
demux :: (Monad m, Ord k)
=> Map k (Fold m a b) -> Fold m (k, a) (Map k b)
demux :: forall (m :: * -> *) k a b.
(Monad m, Ord k) =>
Map k (Fold m a b) -> Fold m (k, a) (Map k b)
demux = forall (m :: * -> *) k a a' b.
(Monad m, Ord k) =>
(a -> (k, a')) -> Map k (Fold m a' b) -> Fold m a (Map k b)
demuxWith forall a. a -> a
id
{-# INLINE demuxWithDefault_ #-}
demuxWithDefault_ :: (Monad m, Ord k)
=> (a -> (k, a')) -> Map k (Fold m a' b) -> Fold m (k, a') b -> Fold m a ()
demuxWithDefault_ :: forall (m :: * -> *) k a a' b.
(Monad m, Ord k) =>
(a -> (k, a'))
-> Map k (Fold m a' b) -> Fold m (k, a') b -> Fold m a ()
demuxWithDefault_ a -> (k, a')
f Map k (Fold m a' b)
kv (Fold s -> (k, a') -> m s
dstep m s
dinitial s -> m b
dextract) =
forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {b}.
Tuple' (Map k (Fold m a' b)) s
-> a -> m (Tuple' (Map k (Fold m a' b)) s)
step m (Tuple' (Map k (Fold m a' b)) s)
initial forall {t :: * -> *} {a} {b}.
Foldable t =>
Tuple' (t (Fold m a b)) s -> m ()
extract
where
initFold :: Fold m a b -> m (Fold m a b)
initFold (Fold s -> a -> m s
s m s
i s -> m b
e) = m s
i forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \s
r -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold s -> a -> m s
s (forall (m :: * -> *) a. Monad m => a -> m a
return s
r) s -> m b
e)
initial :: m (Tuple' (Map k (Fold m a' b)) s)
initial = do
Map k (Fold m a' b)
mp <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
Prelude.mapM forall {m :: * -> *} {a} {b}.
Monad m =>
Fold m a b -> m (Fold m a b)
initFold Map k (Fold m a' b)
kv
s
dacc <- m s
dinitial
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> b -> Tuple' a b
Tuple' Map k (Fold m a' b)
mp s
dacc)
step :: Tuple' (Map k (Fold m a' b)) s
-> a -> m (Tuple' (Map k (Fold m a' b)) s)
step (Tuple' Map k (Fold m a' b)
mp s
dacc) a
a
| (k
k, a'
a') <- a -> (k, a')
f a
a
= case forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup k
k Map k (Fold m a' b)
mp of
Maybe (Fold m a' b)
Nothing -> do
s
acc <- s -> (k, a') -> m s
dstep s
dacc (k
k, a'
a')
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> b -> Tuple' a b
Tuple' Map k (Fold m a' b)
mp s
acc)
Just (Fold s -> a' -> m s
step' m s
acc s -> m b
_) -> do
s
_ <- m s
acc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \s
x -> s -> a' -> m s
step' s
x a'
a'
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> b -> Tuple' a b
Tuple' Map k (Fold m a' b)
mp s
dacc)
extract :: Tuple' (t (Fold m a b)) s -> m ()
extract (Tuple' t (Fold m a b)
mp s
dacc) = do
forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ s -> m b
dextract s
dacc
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
Prelude.mapM_ (\(Fold s -> a -> m s
_ m s
acc s -> m b
e) -> m s
acc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= s -> m b
e) t (Fold m a b)
mp
{-# INLINE demuxWith_ #-}
demuxWith_ :: (Monad m, Ord k)
=> (a -> (k, a')) -> Map k (Fold m a' b) -> Fold m a ()
demuxWith_ :: forall (m :: * -> *) k a a' b.
(Monad m, Ord k) =>
(a -> (k, a')) -> Map k (Fold m a' b) -> Fold m a ()
demuxWith_ a -> (k, a')
f Map k (Fold m a' b)
kv = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *} {b}.
Monad m =>
Map k (Fold m a' b) -> a -> m (Map k (Fold m a' b))
step m (Map k (Fold m a' b))
initial forall {t :: * -> *} {m :: * -> *} {a} {b}.
(Foldable t, Monad m) =>
t (Fold m a b) -> m ()
extract
where
initial :: m (Map k (Fold m a' b))
initial = do
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
Prelude.mapM (\(Fold s -> a' -> m s
s m s
i s -> m b
e) ->
m s
i forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \s
r -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold s -> a' -> m s
s (forall (m :: * -> *) a. Monad m => a -> m a
return s
r) s -> m b
e)) Map k (Fold m a' b)
kv
step :: Map k (Fold m a' b) -> a -> m (Map k (Fold m a' b))
step Map k (Fold m a' b)
mp a
a
| (k
k, a'
a') <- a -> (k, a')
f a
a
= case forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup k
k Map k (Fold m a' b)
mp of
Maybe (Fold m a' b)
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return Map k (Fold m a' b)
mp
Just (Fold s -> a' -> m s
step' m s
acc s -> m b
_) -> do
s
_ <- m s
acc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \s
x -> s -> a' -> m s
step' s
x a'
a'
forall (m :: * -> *) a. Monad m => a -> m a
return Map k (Fold m a' b)
mp
extract :: t (Fold m a b) -> m ()
extract t (Fold m a b)
mp = forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
Prelude.mapM_ (\(Fold s -> a -> m s
_ m s
acc s -> m b
e) -> m s
acc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= s -> m b
e) t (Fold m a b)
mp
{-# INLINE demux_ #-}
demux_ :: (Monad m, Ord k) => Map k (Fold m a ()) -> Fold m (k, a) ()
demux_ :: forall (m :: * -> *) k a.
(Monad m, Ord k) =>
Map k (Fold m a ()) -> Fold m (k, a) ()
demux_ = forall (m :: * -> *) k a a' b.
(Monad m, Ord k) =>
(a -> (k, a')) -> Map k (Fold m a' b) -> Fold m a ()
demuxWith_ forall a. a -> a
id
{-# INLINE demuxDefault_ #-}
demuxDefault_ :: (Monad m, Ord k)
=> Map k (Fold m a ()) -> Fold m (k, a) () -> Fold m (k, a) ()
demuxDefault_ :: forall (m :: * -> *) k a.
(Monad m, Ord k) =>
Map k (Fold m a ()) -> Fold m (k, a) () -> Fold m (k, a) ()
demuxDefault_ = forall (m :: * -> *) k a a' b.
(Monad m, Ord k) =>
(a -> (k, a'))
-> Map k (Fold m a' b) -> Fold m (k, a') b -> Fold m a ()
demuxWithDefault_ forall a. a -> a
id
{-# INLINE classifyWith #-}
classifyWith :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (Map k b)
classifyWith :: forall (m :: * -> *) k a b.
(Monad m, Ord k) =>
(a -> k) -> Fold m a b -> Fold m a (Map k b)
classifyWith a -> k
f (Fold s -> a -> m s
step m s
initial s -> m b
extract) = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold Map k s -> a -> m (Map k s)
step' forall {k} {a}. m (Map k a)
initial' Map k s -> m (Map k b)
extract'
where
initial' :: m (Map k a)
initial' = forall (m :: * -> *) a. Monad m => a -> m a
return forall k a. Map k a
Map.empty
step' :: Map k s -> a -> m (Map k s)
step' Map k s
kv a
a =
let k :: k
k = a -> k
f a
a
in case forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup k
k Map k s
kv of
Maybe s
Nothing -> do
s
x <- m s
initial
s
r <- s -> a -> m s
step s
x a
a
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert k
k s
r Map k s
kv
Just s
x -> do
s
r <- s -> a -> m s
step s
x a
a
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert k
k s
r Map k s
kv
extract' :: Map k s -> m (Map k b)
extract' = forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
Prelude.mapM s -> m b
extract
{-# INLINE classify #-}
classify :: (Monad m, Ord k) => Fold m a b -> Fold m (k, a) (Map k b)
classify :: forall (m :: * -> *) k a b.
(Monad m, Ord k) =>
Fold m a b -> Fold m (k, a) (Map k b)
classify Fold m a b
fld = forall (m :: * -> *) k a b.
(Monad m, Ord k) =>
(a -> k) -> Fold m a b -> Fold m a (Map k b)
classifyWith forall a b. (a, b) -> a
fst (forall a b (m :: * -> *) r. (a -> b) -> Fold m b r -> Fold m a r
lmap forall a b. (a, b) -> b
snd Fold m a b
fld)
{-# INLINE unzipWithM #-}
unzipWithM :: Monad m
=> (a -> m (b,c)) -> Fold m b x -> Fold m c y -> Fold m a (x,y)
unzipWithM :: forall (m :: * -> *) a b c x y.
Monad m =>
(a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
unzipWithM a -> m (b, c)
f (Fold s -> b -> m s
stepL m s
beginL s -> m x
doneL) (Fold s -> c -> m s
stepR m s
beginR s -> m y
doneR) =
forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold Tuple' s s -> a -> m (Tuple' s s)
step m (Tuple' s s)
begin Tuple' s s -> m (x, y)
done
where
step :: Tuple' s s -> a -> m (Tuple' s s)
step (Tuple' s
xL s
xR) a
a = do
(b
b,c
c) <- a -> m (b, c)
f a
a
forall a b. a -> b -> Tuple' a b
Tuple' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> b -> m s
stepL s
xL b
b forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> s -> c -> m s
stepR s
xR c
c
begin :: m (Tuple' s s)
begin = forall a b. a -> b -> Tuple' a b
Tuple' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m s
beginL forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m s
beginR
done :: Tuple' s s -> m (x, y)
done (Tuple' s
xL s
xR) = (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m x
doneL s
xL forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> s -> m y
doneR s
xR
{-# INLINE unzipWith #-}
unzipWith :: Monad m
=> (a -> (b,c)) -> Fold m b x -> Fold m c y -> Fold m a (x,y)
unzipWith :: forall (m :: * -> *) a b c x y.
Monad m =>
(a -> (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
unzipWith a -> (b, c)
f = forall (m :: * -> *) a b c x y.
Monad m =>
(a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
unzipWithM (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> (b, c)
f)
{-# INLINE unzip #-}
unzip :: Monad m => Fold m a x -> Fold m b y -> Fold m (a,b) (x,y)
unzip :: forall (m :: * -> *) a x b y.
Monad m =>
Fold m a x -> Fold m b y -> Fold m (a, b) (x, y)
unzip = forall (m :: * -> *) a b c x y.
Monad m =>
(a -> (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
unzipWith forall a. a -> a
id
{-# INLINABLE foldChunks #-}
foldChunks ::
Fold m a b -> Fold m b c -> Fold m a c
foldChunks :: forall (m :: * -> *) a b c. Fold m a b -> Fold m b c -> Fold m a c
foldChunks = forall a. HasCallStack => a
undefined
{-# INLINE toParallelSVar #-}
toParallelSVar :: MonadIO m => SVar t m a -> Maybe WorkerInfo -> Fold m a ()
toParallelSVar :: forall (m :: * -> *) (t :: (* -> *) -> * -> *) a.
MonadIO m =>
SVar t m a -> Maybe WorkerInfo -> Fold m a ()
toParallelSVar SVar t m a
svar Maybe WorkerInfo
winfo = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *}. MonadIO m => () -> a -> m ()
step m ()
initial forall {m :: * -> *}. MonadIO m => () -> m ()
extract
where
initial :: m ()
initial = forall (m :: * -> *) a. Monad m => a -> m a
return ()
step :: () -> a -> m ()
step () a
x = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
SVar t m a -> IO ()
decrementBufferLimit SVar t m a
svar
forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
SVar t m a -> ChildEvent a -> IO Int
send SVar t m a
svar (forall a. a -> ChildEvent a
ChildYield a
x)
extract :: () -> m ()
extract () = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
SVar t m a -> Maybe WorkerInfo -> IO ()
sendStop SVar t m a
svar Maybe WorkerInfo
winfo
{-# INLINE toParallelSVarLimited #-}
toParallelSVarLimited :: MonadIO m
=> SVar t m a -> Maybe WorkerInfo -> Fold m a ()
toParallelSVarLimited :: forall (m :: * -> *) (t :: (* -> *) -> * -> *) a.
MonadIO m =>
SVar t m a -> Maybe WorkerInfo -> Fold m a ()
toParallelSVarLimited SVar t m a
svar Maybe WorkerInfo
winfo = forall (m :: * -> *) a b s.
(s -> a -> m s) -> m s -> (s -> m b) -> Fold m a b
Fold forall {m :: * -> *}. MonadIO m => Bool -> a -> m Bool
step m Bool
initial forall {m :: * -> *}. MonadIO m => Bool -> m ()
extract
where
initial :: m Bool
initial = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
step :: Bool -> a -> m Bool
step Bool
True a
x = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Bool
yieldLimitOk <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
SVar t m a -> IO Bool
decrementYieldLimit SVar t m a
svar
if Bool
yieldLimitOk
then do
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
SVar t m a -> IO ()
decrementBufferLimit SVar t m a
svar
forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
SVar t m a -> ChildEvent a -> IO Int
send SVar t m a
svar (forall a. a -> ChildEvent a
ChildYield a
x)
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
else do
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
SVar t m a -> IO ()
cleanupSVarFromWorker SVar t m a
svar
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
SVar t m a -> Maybe WorkerInfo -> IO ()
sendStop SVar t m a
svar Maybe WorkerInfo
winfo
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
step Bool
False a
_ = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
extract :: Bool -> m ()
extract Bool
True = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
SVar t m a -> Maybe WorkerInfo -> IO ()
sendStop SVar t m a
svar Maybe WorkerInfo
winfo
extract Bool
False = forall (m :: * -> *) a. Monad m => a -> m a
return ()