{-# LANGUAGE CPP #-}
module Streamly.Internal.Data.Fold.Combinators
(
tracing
, trace
, sconcat
, mconcat
, foldMap
, foldMapM
, drainMapM
, the
, mean
, rollingHash
, Scanl.defaultSalt
, rollingHashWithSalt
, rollingHashFirstN
, sum
, product
, maximumBy
, maximum
, minimumBy
, minimum
, rangeBy
, range
, toStream
, toStreamRev
, topBy
, top
, bottomBy
, bottom
, rollingMap
, rollingMapM
, deleteBy
, uniqBy
, uniq
, repeated
, findIndices
, elemIndices
, one
, null
, satisfy
, maybe
, drainN
, genericIndex
, index
, findM
, find
, lookup
, findIndex
, elemIndex
, elem
, notElem
, all
, any
, and
, or
, takingEndByM
, takingEndBy
, takingEndByM_
, takingEndBy_
, droppingWhileM
, droppingWhile
, prune
, drive
, addStream
, with
, slide2
, pipe
, indexed
, zipStreamWithM
, zipStream
, mapMaybeM
, mapMaybe
, sampleFromthen
, takeEndBySeq
, takeEndBySeq_
, splitAt
, tee
, distribute
, distributeScan
, unzip
, unzipWith
, unzipWithM
, unzipWithFstM
, unzipWithMinM
, partitionByM
, partitionByFstM
, partitionByMinM
, partitionBy
, partition
, chunksBetween
, intersperseWithQuotes
, unfoldMany
, concatSequence
, drainBy
, head
, sequence
, mapM
, variance
, stdDev
, indexingWith
, indexing
, indexingRev
)
where
#include "inline.hs"
#include "ArrayMacros.h"
import Control.Monad (void)
import Control.Monad.IO.Class (MonadIO(..))
import Data.Bifunctor (first)
import Data.Bits (shiftL, shiftR, (.|.), (.&.))
import Data.Either (isLeft, isRight, fromLeft, fromRight)
import Data.Int (Int64)
import Data.Proxy (Proxy(..))
import Data.Word (Word32)
import Streamly.Internal.Data.Array.Type (Array(..))
import Streamly.Internal.Data.Scanl.Type (Scanl(..))
import Streamly.Internal.Data.Unbox (Unbox(..))
import Streamly.Internal.Data.MutArray.Type (MutArray(..))
import Streamly.Internal.Data.Maybe.Strict (Maybe'(..), toMaybe)
import Streamly.Internal.Data.Pipe.Type (Pipe (..))
import Streamly.Internal.Data.RingArray (RingArray(..))
import Streamly.Internal.Data.Stream.Type (Stream)
import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))
import Streamly.Internal.Data.Unfold.Type (Unfold(..))
import qualified Prelude
import qualified Streamly.Internal.Data.MutArray.Type as MA
import qualified Streamly.Internal.Data.Array.Type as Array
import qualified Streamly.Internal.Data.Pipe.Type as Pipe
import qualified Streamly.Internal.Data.RingArray as RingArray
import qualified Streamly.Internal.Data.Scanl.Combinators as Scanl
import qualified Streamly.Internal.Data.Scanl.Type as Scanl
import qualified Streamly.Internal.Data.Stream.Type as StreamD
import Prelude hiding
( Foldable(..), filter, drop, dropWhile, take, takeWhile, zipWith
, map, mapM_, sequence, all, any
, notElem, head, last, tail
, reverse, iterate, init, and, or, lookup, (!!)
, scanl, scanl1, replicate, concatMap, mconcat, unzip
, span, splitAt, break, mapM, zip, maybe)
import Streamly.Internal.Data.Fold.Type
#include "DocTestDataFold.hs"
{-# INLINE drive #-}
drive :: Monad m => Stream m a -> Fold m a b -> m b
drive :: forall (m :: * -> *) a b.
Monad m =>
Stream m a -> Fold m a b -> m b
drive = (Fold m a b -> Stream m a -> m b)
-> Stream m a -> Fold m a b -> m b
forall a b c. (a -> b -> c) -> b -> a -> c
flip Fold m a b -> Stream m a -> m b
forall (m :: * -> *) a b.
Monad m =>
Fold m a b -> Stream m a -> m b
StreamD.fold
addStream :: Monad m => Stream m a -> Fold m a b -> m (Fold m a b)
addStream :: forall (m :: * -> *) a b.
Monad m =>
Stream m a -> Fold m a b -> m (Fold m a b)
addStream Stream m a
stream = Stream m a -> Fold m a (Fold m a b) -> m (Fold m a b)
forall (m :: * -> *) a b.
Monad m =>
Stream m a -> Fold m a b -> m b
drive Stream m a
stream (Fold m a (Fold m a b) -> m (Fold m a b))
-> (Fold m a b -> Fold m a (Fold m a b))
-> Fold m a b
-> m (Fold m a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fold m a b -> Fold m a (Fold m a b)
forall (m :: * -> *) a b.
Monad m =>
Fold m a b -> Fold m a (Fold m a b)
duplicate
{-# DEPRECATED sequence "Use \"rmapM id\" instead" #-}
{-# 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 = (m b -> m b) -> Fold m a (m b) -> Fold m a b
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> Fold m a b -> Fold m a c
rmapM m b -> m b
forall a. a -> a
id
{-# DEPRECATED mapM "Use rmapM instead" #-}
{-# 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) -> Fold m a b -> Fold m a c
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> Fold m a b -> Fold m a c
rmapM
{-# INLINE mapMaybeM #-}
mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Fold m b r -> Fold m a r
mapMaybeM :: forall (m :: * -> *) a b r.
Monad m =>
(a -> m (Maybe b)) -> Fold m b r -> Fold m a r
mapMaybeM a -> m (Maybe b)
f = (a -> m (Maybe b)) -> Fold m (Maybe b) r -> Fold m a r
forall (m :: * -> *) a b r.
Monad m =>
(a -> m b) -> Fold m b r -> Fold m a r
lmapM a -> m (Maybe b)
f (Fold m (Maybe b) r -> Fold m a r)
-> (Fold m b r -> Fold m (Maybe b) r) -> Fold m b r -> Fold m a r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fold m b r -> Fold m (Maybe b) r
forall (m :: * -> *) a b.
Monad m =>
Fold m a b -> Fold m (Maybe a) b
catMaybes
{-# INLINE mapMaybe #-}
mapMaybe :: Monad m => (a -> Maybe b) -> Fold m b r -> Fold m a r
mapMaybe :: forall (m :: * -> *) a b r.
Monad m =>
(a -> Maybe b) -> Fold m b r -> Fold m a r
mapMaybe a -> Maybe b
f = (a -> Maybe b) -> Fold m (Maybe b) r -> Fold m a r
forall a b (m :: * -> *) r. (a -> b) -> Fold m b r -> Fold m a r
lmap a -> Maybe b
f (Fold m (Maybe b) r -> Fold m a r)
-> (Fold m b r -> Fold m (Maybe b) r) -> Fold m b r -> Fold m a r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fold m b r -> Fold m (Maybe b) r
forall (m :: * -> *) a b.
Monad m =>
Fold m a b -> Fold m (Maybe a) b
catMaybes
{-# INLINE tracing #-}
tracing :: Monad m => (a -> m b) -> (a -> m a)
tracing :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> a -> m a
tracing a -> m b
f a
x = m b -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (a -> m b
f a
x) m () -> m a -> m a
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x
{-# INLINE trace #-}
trace :: Monad m => (a -> m b) -> Fold m a r -> Fold m a r
trace :: forall (m :: * -> *) a b r.
Monad m =>
(a -> m b) -> Fold m a r -> Fold m a r
trace a -> m b
f = (a -> m a) -> Fold m a r -> Fold m a r
forall (m :: * -> *) a b r.
Monad m =>
(a -> m b) -> Fold m b r -> Fold m a r
lmapM ((a -> m b) -> a -> m a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> a -> m a
tracing a -> m b
f)
{-# INLINE pipe #-}
pipe :: Monad m => Pipe m a b -> Fold m b c -> Fold m a c
pipe :: forall (m :: * -> *) a b c.
Monad m =>
Pipe m a b -> Fold m b c -> Fold m a c
pipe (Pipe cs -> a -> m (Step cs ps b)
consume ps -> m (Step cs ps b)
produce cs
pinitial) (Fold s -> b -> m (Step s c)
fstep m (Step s c)
finitial s -> m c
fextract s -> m c
ffinal) =
(Tuple' cs s -> a -> m (Step (Tuple' cs s) c))
-> m (Step (Tuple' cs s) c)
-> (Tuple' cs s -> m c)
-> (Tuple' cs s -> m c)
-> Fold m a c
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
Fold Tuple' cs s -> a -> m (Step (Tuple' cs s) c)
step m (Step (Tuple' cs s) c)
initial Tuple' cs s -> m c
forall {a}. Tuple' a s -> m c
extract Tuple' cs s -> m c
forall {a}. Tuple' a s -> m c
final
where
initial :: m (Step (Tuple' cs s) c)
initial = (s -> Tuple' cs s) -> Step s c -> Step (Tuple' cs s) c
forall a b c. (a -> b) -> Step a c -> Step b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (cs -> s -> Tuple' cs s
forall a b. a -> b -> Tuple' a b
Tuple' cs
pinitial) (Step s c -> Step (Tuple' cs s) c)
-> m (Step s c) -> m (Step (Tuple' cs s) c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Step s c)
finitial
step :: Tuple' cs s -> a -> m (Step (Tuple' cs s) c)
step (Tuple' cs
cs s
fs) a
x = do
Step cs ps b
r <- cs -> a -> m (Step cs ps b)
consume cs
cs a
x
s -> Step cs ps b -> m (Step (Tuple' cs s) c)
go s
fs Step cs ps b
r
where
go :: s -> Step cs ps b -> m (Step (Tuple' cs s) c)
go s
acc (Pipe.YieldC cs
cs1 b
b) = do
Step s c
acc1 <- s -> b -> m (Step s c)
fstep s
acc b
b
Step (Tuple' cs s) c -> m (Step (Tuple' cs s) c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
(Step (Tuple' cs s) c -> m (Step (Tuple' cs s) c))
-> Step (Tuple' cs s) c -> m (Step (Tuple' cs s) c)
forall a b. (a -> b) -> a -> b
$ case Step s c
acc1 of
Partial s
s -> Tuple' cs s -> Step (Tuple' cs s) c
forall s b. s -> Step s b
Partial (Tuple' cs s -> Step (Tuple' cs s) c)
-> Tuple' cs s -> Step (Tuple' cs s) c
forall a b. (a -> b) -> a -> b
$ cs -> s -> Tuple' cs s
forall a b. a -> b -> Tuple' a b
Tuple' cs
cs1 s
s
Done c
b1 -> c -> Step (Tuple' cs s) c
forall s b. b -> Step s b
Done c
b1
go s
acc (Pipe.YieldP ps
ps1 b
b) = do
Step s c
acc1 <- s -> b -> m (Step s c)
fstep s
acc b
b
Step cs ps b
r <- ps -> m (Step cs ps b)
produce ps
ps1
case Step s c
acc1 of
Partial s
s -> s -> Step cs ps b -> m (Step (Tuple' cs s) c)
go s
s Step cs ps b
r
Done c
b1 -> Step (Tuple' cs s) c -> m (Step (Tuple' cs s) c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Tuple' cs s) c -> m (Step (Tuple' cs s) c))
-> Step (Tuple' cs s) c -> m (Step (Tuple' cs s) c)
forall a b. (a -> b) -> a -> b
$ c -> Step (Tuple' cs s) c
forall s b. b -> Step s b
Done c
b1
go s
acc (Pipe.SkipC cs
cs1) =
Step (Tuple' cs s) c -> m (Step (Tuple' cs s) c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Tuple' cs s) c -> m (Step (Tuple' cs s) c))
-> Step (Tuple' cs s) c -> m (Step (Tuple' cs s) c)
forall a b. (a -> b) -> a -> b
$ Tuple' cs s -> Step (Tuple' cs s) c
forall s b. s -> Step s b
Partial (Tuple' cs s -> Step (Tuple' cs s) c)
-> Tuple' cs s -> Step (Tuple' cs s) c
forall a b. (a -> b) -> a -> b
$ cs -> s -> Tuple' cs s
forall a b. a -> b -> Tuple' a b
Tuple' cs
cs1 s
acc
go s
acc (Pipe.SkipP ps
ps1) = do
Step cs ps b
r <- ps -> m (Step cs ps b)
produce ps
ps1
s -> Step cs ps b -> m (Step (Tuple' cs s) c)
go s
acc Step cs ps b
r
go s
acc Step cs ps b
Pipe.Stop = c -> Step (Tuple' cs s) c
forall s b. b -> Step s b
Done (c -> Step (Tuple' cs s) c) -> m c -> m (Step (Tuple' cs s) c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m c
ffinal s
acc
extract :: Tuple' a s -> m c
extract (Tuple' a
_ s
fs) = s -> m c
fextract s
fs
final :: Tuple' a s -> m c
final (Tuple' a
_ s
fs) = s -> m c
ffinal s
fs
{-# INLINE_NORMAL deleteBy #-}
deleteBy :: Monad m => (a -> a -> Bool) -> a -> Fold m a (Maybe a)
deleteBy :: forall (m :: * -> *) a.
Monad m =>
(a -> a -> Bool) -> a -> Fold m a (Maybe a)
deleteBy a -> a -> Bool
eq = Scanl m a (Maybe a) -> Fold m a (Maybe a)
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a (Maybe a) -> Fold m a (Maybe a))
-> (a -> Scanl m a (Maybe a)) -> a -> Fold m a (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> Bool) -> a -> Scanl m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> a -> Bool) -> a -> Scanl m a (Maybe a)
Scanl.deleteBy a -> a -> Bool
eq
{-# INLINE slide2 #-}
slide2 :: Monad m => Fold m (a, Maybe a) b -> Fold m a b
slide2 :: forall (m :: * -> *) a b.
Monad m =>
Fold m (a, Maybe a) b -> Fold m a b
slide2 (Fold s -> (a, Maybe a) -> m (Step s b)
step1 m (Step s b)
initial1 s -> m b
extract1 s -> m b
final1) = (Tuple' (Maybe a) s -> a -> m (Step (Tuple' (Maybe a) s) b))
-> m (Step (Tuple' (Maybe a) s) b)
-> (Tuple' (Maybe a) s -> m b)
-> (Tuple' (Maybe a) s -> m b)
-> Fold m a b
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
Fold Tuple' (Maybe a) s -> a -> m (Step (Tuple' (Maybe a) s) b)
step m (Step (Tuple' (Maybe a) s) b)
forall {a}. m (Step (Tuple' (Maybe a) s) b)
initial Tuple' (Maybe a) s -> m b
forall {a}. Tuple' a s -> m b
extract Tuple' (Maybe a) s -> m b
forall {a}. Tuple' a s -> m b
final
where
initial :: m (Step (Tuple' (Maybe a) s) b)
initial =
(s -> Tuple' (Maybe a) s)
-> Step s b -> Step (Tuple' (Maybe a) s) b
forall a b c. (a -> b) -> Step a c -> Step b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (Maybe a -> s -> Tuple' (Maybe a) s
forall a b. a -> b -> Tuple' a b
Tuple' Maybe a
forall a. Maybe a
Nothing) (Step s b -> Step (Tuple' (Maybe a) s) b)
-> m (Step s b) -> m (Step (Tuple' (Maybe a) s) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Step s b)
initial1
step :: Tuple' (Maybe a) s -> a -> m (Step (Tuple' (Maybe a) s) b)
step (Tuple' Maybe a
prev s
s) a
cur =
(s -> Tuple' (Maybe a) s)
-> Step s b -> Step (Tuple' (Maybe a) s) b
forall a b c. (a -> b) -> Step a c -> Step b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (Maybe a -> s -> Tuple' (Maybe a) s
forall a b. a -> b -> Tuple' a b
Tuple' (a -> Maybe a
forall a. a -> Maybe a
Just a
cur)) (Step s b -> Step (Tuple' (Maybe a) s) b)
-> m (Step s b) -> m (Step (Tuple' (Maybe a) s) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> (a, Maybe a) -> m (Step s b)
step1 s
s (a
cur, Maybe a
prev)
extract :: Tuple' a s -> m b
extract (Tuple' a
_ s
s) = s -> m b
extract1 s
s
final :: Tuple' a s -> m b
final (Tuple' a
_ s
s) = s -> m b
final1 s
s
{-# INLINE uniqBy #-}
uniqBy :: Monad m => (a -> a -> Bool) -> Fold m a (Maybe a)
uniqBy :: forall (m :: * -> *) a.
Monad m =>
(a -> a -> Bool) -> Fold m a (Maybe a)
uniqBy = Scanl m a (Maybe a) -> Fold m a (Maybe a)
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a (Maybe a) -> Fold m a (Maybe a))
-> ((a -> a -> Bool) -> Scanl m a (Maybe a))
-> (a -> a -> Bool)
-> Fold m a (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> Bool) -> Scanl m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> a -> Bool) -> Scanl m a (Maybe a)
Scanl.uniqBy
{-# INLINE uniq #-}
uniq :: (Monad m, Eq a) => Fold m a (Maybe a)
uniq :: forall (m :: * -> *) a. (Monad m, Eq a) => Fold m a (Maybe a)
uniq = Scanl m a (Maybe a) -> Fold m a (Maybe a)
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl Scanl m a (Maybe a)
forall (m :: * -> *) a. (Monad m, Eq a) => Scanl m a (Maybe a)
Scanl.uniq
{-# INLINE prune #-}
prune ::
(a -> Bool) -> Fold m a (Maybe a)
prune :: forall a (m :: * -> *). (a -> Bool) -> Fold m a (Maybe a)
prune = [Char] -> (a -> Bool) -> Fold m a (Maybe a)
forall a. HasCallStack => [Char] -> a
error [Char]
"Not implemented yet!"
repeated ::
Fold m a (Maybe a)
repeated :: forall (m :: * -> *) a. Fold m a (Maybe a)
repeated = [Char] -> Fold m a (Maybe a)
forall a. HasCallStack => [Char] -> a
error [Char]
"Not implemented yet!"
{-# INLINE drainMapM #-}
drainMapM :: Monad m => (a -> m b) -> Fold m a ()
drainMapM :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> Fold m a ()
drainMapM a -> m b
f = (a -> m b) -> Fold m b () -> Fold m a ()
forall (m :: * -> *) a b r.
Monad m =>
(a -> m b) -> Fold m b r -> Fold m a r
lmapM a -> m b
f Fold m b ()
forall (m :: * -> *) a. Monad m => Fold m a ()
drain
{-# DEPRECATED drainBy "Please use 'drainMapM' instead." #-}
{-# INLINE 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) -> Fold m a ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> Fold m a ()
drainMapM
{-# INLINE the #-}
the :: (Monad m, Eq a) => Fold m a (Maybe a)
the :: forall (m :: * -> *) a. (Monad m, Eq a) => Fold m a (Maybe a)
the = Scanl m a (Maybe a) -> Fold m a (Maybe a)
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl Scanl m a (Maybe a)
forall (m :: * -> *) a. (Monad m, Eq a) => Scanl m a (Maybe a)
Scanl.the
{-# INLINE sum #-}
sum :: (Monad m, Num a) => Fold m a a
sum :: forall (m :: * -> *) a. (Monad m, Num a) => Fold m a a
sum = Scanl m a a -> Fold m a a
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl Scanl m a a
forall (m :: * -> *) a. (Monad m, Num a) => Scanl m a a
Scanl.sum
{-# INLINE product #-}
product :: (Monad m, Num a, Eq a) => Fold m a a
product :: forall (m :: * -> *) a. (Monad m, Num a, Eq a) => Fold m a a
product = Scanl m a a -> Fold m a a
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl Scanl m a a
forall (m :: * -> *) a. (Monad m, Num a, Eq a) => Scanl m a a
Scanl.product
{-# INLINE 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 = (a -> a -> a) -> Fold m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Fold m a (Maybe a)
foldl1' 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
{-# INLINE 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 = (a -> a -> a) -> Fold m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Fold m a (Maybe a)
foldl1' a -> a -> a
forall a. Ord a => a -> a -> a
max
{-# INLINE 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 = (a -> a -> a) -> Fold m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Fold m a (Maybe a)
foldl1' 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
{-# INLINE 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 = (a -> a -> a) -> Fold m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Fold m a (Maybe a)
foldl1' a -> a -> a
forall a. Ord a => a -> a -> a
min
{-# INLINE rangeBy #-}
rangeBy :: Monad m => (a -> a -> Ordering) -> Fold m a (Maybe (a, a))
rangeBy :: forall (m :: * -> *) a.
Monad m =>
(a -> a -> Ordering) -> Fold m a (Maybe (a, a))
rangeBy a -> a -> Ordering
cmp = Scanl m a (Maybe (a, a)) -> Fold m a (Maybe (a, a))
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl ((a -> a -> Ordering) -> Scanl m a (Maybe (a, a))
forall (m :: * -> *) a.
Monad m =>
(a -> a -> Ordering) -> Scanl m a (Maybe (a, a))
Scanl.rangeBy a -> a -> Ordering
cmp)
{-# INLINE range #-}
range :: (Monad m, Ord a) => Fold m a (Maybe (a, a))
range :: forall (m :: * -> *) a. (Monad m, Ord a) => Fold m a (Maybe (a, a))
range = Scanl m a (Maybe (a, a)) -> Fold m a (Maybe (a, a))
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl Scanl m a (Maybe (a, a))
forall (m :: * -> *) a.
(Monad m, Ord a) =>
Scanl m a (Maybe (a, a))
Scanl.range
{-# INLINE mean #-}
mean :: (Monad m, Fractional a) => Fold m a a
mean :: forall (m :: * -> *) a. (Monad m, Fractional a) => Fold m a a
mean = Scanl m a a -> Fold m a a
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl Scanl m a a
forall (m :: * -> *) a. (Monad m, Fractional a) => Scanl m a a
Scanl.mean
{-# DEPRECATED variance "Use the streamly-statistics package instead" #-}
{-# INLINE variance #-}
variance :: (Monad m, Fractional a) => Fold m a a
variance :: forall (m :: * -> *) a. (Monad m, Fractional a) => Fold m a a
variance = (Tuple3' a a a -> a) -> Fold m a (Tuple3' a a a) -> Fold m a a
forall a b. (a -> b) -> Fold m a a -> Fold m a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Tuple3' a a a -> a
forall {a} {b}. Fractional a => Tuple3' a b a -> a
done (Fold m a (Tuple3' a a a) -> Fold m a a)
-> Fold m a (Tuple3' a a a) -> Fold m a a
forall a b. (a -> b) -> a -> b
$ (Tuple3' a a a -> a -> Tuple3' a a a)
-> Tuple3' a a a -> Fold m a (Tuple3' a a a)
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Fold m a b
foldl' Tuple3' a a a -> a -> Tuple3' a a a
forall {c}. Fractional c => Tuple3' c c c -> c -> Tuple3' c c c
step Tuple3' a a a
begin
where
begin :: Tuple3' a a a
begin = a -> a -> a -> Tuple3' a a a
forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' a
0 a
0 a
0
step :: Tuple3' c c c -> c -> Tuple3' c c c
step (Tuple3' c
n c
mean_ c
m2) c
x = c -> c -> c -> Tuple3' c c c
forall a b c. a -> b -> c -> Tuple3' a b c
Tuple3' c
n' c
mean' c
m2'
where
n' :: c
n' = c
n c -> c -> c
forall a. Num a => a -> a -> a
+ c
1
mean' :: c
mean' = (c
n c -> c -> c
forall a. Num a => a -> a -> a
* c
mean_ c -> c -> c
forall a. Num a => a -> a -> a
+ c
x) c -> c -> c
forall a. Fractional a => a -> a -> a
/ (c
n c -> c -> c
forall a. Num a => a -> a -> a
+ c
1)
delta :: c
delta = c
x c -> c -> c
forall a. Num a => a -> a -> a
- c
mean_
m2' :: c
m2' = c
m2 c -> c -> c
forall a. Num a => a -> a -> a
+ c
delta c -> c -> c
forall a. Num a => a -> a -> a
* c
delta c -> c -> c
forall a. Num a => a -> a -> a
* c
n c -> c -> c
forall a. Fractional a => a -> a -> a
/ (c
n c -> c -> c
forall a. Num a => a -> a -> a
+ c
1)
done :: Tuple3' a b a -> a
done (Tuple3' a
n b
_ a
m2) = a
m2 a -> a -> a
forall a. Fractional a => a -> a -> a
/ a
n
{-# DEPRECATED stdDev "Use the streamly-statistics package instead" #-}
{-# INLINE stdDev #-}
stdDev :: (Monad m, Floating a) => Fold m a a
stdDev :: forall (m :: * -> *) a. (Monad m, Floating a) => Fold m a a
stdDev = a -> a
forall a. Floating a => a -> a
sqrt (a -> a) -> Fold m a a -> Fold m a a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fold m a a
forall (m :: * -> *) a. (Monad m, Fractional a) => Fold m a a
variance
{-# INLINE 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 = Scanl m a Int64 -> Fold m a Int64
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a Int64 -> Fold m a Int64)
-> (Int64 -> Scanl m a Int64) -> Int64 -> Fold m a Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Scanl m a Int64
forall (m :: * -> *) a.
(Monad m, Enum a) =>
Int64 -> Scanl m a Int64
Scanl.rollingHashWithSalt
{-# INLINE rollingHash #-}
rollingHash :: (Monad m, Enum a) => Fold m a Int64
rollingHash :: forall (m :: * -> *) a. (Monad m, Enum a) => Fold m a Int64
rollingHash = Scanl m a Int64 -> Fold m a Int64
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl Scanl m a Int64
forall (m :: * -> *) a. (Monad m, Enum a) => Scanl m a Int64
Scanl.rollingHash
{-# INLINE 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 = Scanl m a Int64 -> Fold m a Int64
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a Int64 -> Fold m a Int64)
-> (Int -> Scanl m a Int64) -> Int -> Fold m a Int64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Scanl m a Int64
forall (m :: * -> *) a. (Monad m, Enum a) => Int -> Scanl m a Int64
Scanl.rollingHashFirstN
{-# INLINE rollingMapM #-}
rollingMapM :: Monad m => (Maybe a -> a -> m b) -> Fold m a b
rollingMapM :: forall (m :: * -> *) a b.
Monad m =>
(Maybe a -> a -> m b) -> Fold m a b
rollingMapM = Scanl m a b -> Fold m a b
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a b -> Fold m a b)
-> ((Maybe a -> a -> m b) -> Scanl m a b)
-> (Maybe a -> a -> m b)
-> Fold m a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe a -> a -> m b) -> Scanl m a b
forall (m :: * -> *) a b.
Monad m =>
(Maybe a -> a -> m b) -> Scanl m a b
Scanl.rollingMapM
{-# INLINE rollingMap #-}
rollingMap :: Monad m => (Maybe a -> a -> b) -> Fold m a b
rollingMap :: forall (m :: * -> *) a b.
Monad m =>
(Maybe a -> a -> b) -> Fold m a b
rollingMap = Scanl m a b -> Fold m a b
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a b -> Fold m a b)
-> ((Maybe a -> a -> b) -> Scanl m a b)
-> (Maybe a -> a -> b)
-> Fold m a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe a -> a -> b) -> Scanl m a b
forall (m :: * -> *) a b.
Monad m =>
(Maybe a -> a -> b) -> Scanl m a b
Scanl.rollingMap
{-# INLINE sconcat #-}
sconcat :: (Monad m, Semigroup a) => a -> Fold m a a
sconcat :: forall (m :: * -> *) a. (Monad m, Semigroup a) => a -> Fold m a a
sconcat = Scanl m a a -> Fold m a a
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a a -> Fold m a a)
-> (a -> Scanl m a a) -> a -> Fold m a a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Scanl m a a
forall (m :: * -> *) a. (Monad m, Semigroup a) => a -> Scanl m a a
Scanl.sconcat
{-# INLINE mconcat #-}
mconcat ::
( Monad m
, Monoid a) => Fold m a a
mconcat :: forall (m :: * -> *) a. (Monad m, Monoid a) => Fold m a a
mconcat = Scanl m a a -> Fold m a a
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl Scanl m a a
forall (m :: * -> *) a. (Monad m, Monoid a) => Scanl m a a
Scanl.mconcat
{-# INLINE 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 = Scanl m a b -> Fold m a b
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a b -> Fold m a b)
-> ((a -> b) -> Scanl m a b) -> (a -> b) -> Fold m a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> Scanl m a b
forall (m :: * -> *) b a.
(Monad m, Monoid b) =>
(a -> b) -> Scanl m a b
Scanl.foldMap
{-# INLINE 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 = Scanl m a b -> Fold m a b
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a b -> Fold m a b)
-> ((a -> m b) -> Scanl m a b) -> (a -> m b) -> Fold m a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> m b) -> Scanl m a b
forall (m :: * -> *) b a.
(Monad m, Monoid b) =>
(a -> m b) -> Scanl m a b
Scanl.foldMapM
{-# INLINE drainN #-}
drainN :: Monad m => Int -> Fold m a ()
drainN :: forall (m :: * -> *) a. Monad m => Int -> Fold m a ()
drainN = Scanl m a () -> Fold m a ()
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a () -> Fold m a ())
-> (Int -> Scanl m a ()) -> Int -> Fold m a ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Scanl m a ()
forall (m :: * -> *) a. Monad m => Int -> Scanl m a ()
Scanl.drainN
{-# INLINE 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 = (i -> a -> Step i (Maybe a))
-> Step i (Maybe a) -> (i -> Maybe a) -> Fold m a (Maybe a)
forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> Step s b) -> Step s b -> (s -> b) -> Fold m a b
foldt' i -> a -> Step i (Maybe a)
forall {a}. i -> a -> Step i (Maybe a)
step (i -> Step i (Maybe a)
forall s b. s -> Step s b
Partial i
0) (Maybe a -> i -> Maybe a
forall a b. a -> b -> a
const Maybe a
forall a. Maybe a
Nothing)
where
step :: i -> a -> Step i (Maybe a)
step i
j a
a =
if i
i i -> i -> Bool
forall a. Eq a => a -> a -> Bool
== i
j
then Maybe a -> Step i (Maybe a)
forall s b. b -> Step s b
Done (Maybe a -> Step i (Maybe a)) -> Maybe a -> Step i (Maybe a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a
forall a. a -> Maybe a
Just a
a
else i -> Step i (Maybe a)
forall s b. s -> Step s b
Partial (i
j i -> i -> i
forall a. Num a => a -> a -> a
+ i
1)
{-# INLINE index #-}
index :: Monad m => Int -> Fold m a (Maybe a)
index :: forall (m :: * -> *) a. Monad m => Int -> Fold m a (Maybe a)
index = Int -> Fold m a (Maybe a)
forall i (m :: * -> *) a.
(Integral i, Monad m) =>
i -> Fold m a (Maybe a)
genericIndex
{-# INLINE maybe #-}
maybe :: Monad m => (a -> Maybe b) -> Fold m a (Maybe b)
maybe :: forall (m :: * -> *) a b.
Monad m =>
(a -> Maybe b) -> Fold m a (Maybe b)
maybe a -> Maybe b
f = (Maybe b -> a -> Step (Maybe b) (Maybe b))
-> Step (Maybe b) (Maybe b)
-> (Maybe b -> Maybe b)
-> Fold m a (Maybe b)
forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> Step s b) -> Step s b -> (s -> b) -> Fold m a b
foldt' ((a -> Step (Maybe b) (Maybe b))
-> Maybe b -> a -> Step (Maybe b) (Maybe b)
forall a b. a -> b -> a
const (Maybe b -> Step (Maybe b) (Maybe b)
forall s b. b -> Step s b
Done (Maybe b -> Step (Maybe b) (Maybe b))
-> (a -> Maybe b) -> a -> Step (Maybe b) (Maybe b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Maybe b
f)) (Maybe b -> Step (Maybe b) (Maybe b)
forall s b. s -> Step s b
Partial Maybe b
forall a. Maybe a
Nothing) Maybe b -> Maybe b
forall a. a -> a
id
{-# INLINE satisfy #-}
satisfy :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
satisfy :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Fold m a (Maybe a)
satisfy a -> Bool
f = (a -> Maybe a) -> Fold m a (Maybe a)
forall (m :: * -> *) a b.
Monad m =>
(a -> Maybe b) -> Fold m a (Maybe b)
maybe (\a
a -> if a -> Bool
f a
a then a -> Maybe a
forall a. a -> Maybe a
Just a
a else Maybe a
forall a. Maybe a
Nothing)
{-# INLINE one #-}
one :: Monad m => Fold m a (Maybe a)
one :: forall (m :: * -> *) a. Monad m => Fold m a (Maybe a)
one = (a -> Maybe a) -> Fold m a (Maybe a)
forall (m :: * -> *) a b.
Monad m =>
(a -> Maybe b) -> Fold m a (Maybe b)
maybe a -> Maybe a
forall a. a -> Maybe a
Just
{-# DEPRECATED head "Please use \"one\" instead" #-}
{-# INLINE head #-}
head :: Monad m => Fold m a (Maybe a)
head :: forall (m :: * -> *) a. Monad m => Fold m a (Maybe a)
head = Fold m a (Maybe a)
forall (m :: * -> *) a. Monad m => Fold m a (Maybe a)
one
{-# INLINE findM #-}
findM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
findM :: forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Fold m a (Maybe a)
findM a -> m Bool
predicate =
(() -> a -> m (Step () (Maybe a)))
-> m (Step () (Maybe a))
-> (() -> m (Maybe a))
-> (() -> m (Maybe a))
-> Fold m a (Maybe a)
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
Fold () -> a -> m (Step () (Maybe a))
step (Step () (Maybe a) -> m (Step () (Maybe a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step () (Maybe a) -> m (Step () (Maybe a)))
-> Step () (Maybe a) -> m (Step () (Maybe a))
forall a b. (a -> b) -> a -> b
$ () -> Step () (Maybe a)
forall s b. s -> Step s b
Partial ()) () -> m (Maybe a)
forall {b} {a}. b -> m (Maybe a)
extract () -> m (Maybe a)
forall {b} {a}. b -> m (Maybe a)
extract
where
step :: () -> a -> m (Step () (Maybe a))
step () a
a =
let f :: Bool -> Step () (Maybe a)
f Bool
r =
if Bool
r
then Maybe a -> Step () (Maybe a)
forall s b. b -> Step s b
Done (a -> Maybe a
forall a. a -> Maybe a
Just a
a)
else () -> Step () (Maybe a)
forall s b. s -> Step s b
Partial ()
in Bool -> Step () (Maybe a)
f (Bool -> Step () (Maybe a)) -> m Bool -> m (Step () (Maybe a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> m Bool
predicate a
a
extract :: b -> m (Maybe a)
extract = m (Maybe a) -> b -> m (Maybe a)
forall a b. a -> b -> a
const (m (Maybe a) -> b -> m (Maybe a))
-> m (Maybe a) -> b -> m (Maybe a)
forall a b. (a -> b) -> a -> b
$ Maybe a -> m (Maybe a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing
{-# INLINE 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
p = (a -> m Bool) -> Fold m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Fold m a (Maybe a)
findM (Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> m Bool) -> (a -> Bool) -> a -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
p)
{-# INLINE 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 = (() -> (a, b) -> Step () (Maybe b))
-> Step () (Maybe b) -> (() -> Maybe b) -> Fold m (a, b) (Maybe b)
forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> Step s b) -> Step s b -> (s -> b) -> Fold m a b
foldt' () -> (a, b) -> Step () (Maybe b)
forall {a}. () -> (a, a) -> Step () (Maybe a)
step (() -> Step () (Maybe b)
forall s b. s -> Step s b
Partial ()) (Maybe b -> () -> Maybe b
forall a b. a -> b -> a
const Maybe b
forall a. Maybe a
Nothing)
where
step :: () -> (a, a) -> Step () (Maybe a)
step () (a
a, a
b) =
if a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
a0
then Maybe a -> Step () (Maybe a)
forall s b. b -> Step s b
Done (Maybe a -> Step () (Maybe a)) -> Maybe a -> Step () (Maybe a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a
forall a. a -> Maybe a
Just a
b
else () -> Step () (Maybe a)
forall s b. s -> Step s b
Partial ()
{-# INLINE 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 = (Int -> a -> Step Int (Maybe Int))
-> Step Int (Maybe Int)
-> (Int -> Maybe Int)
-> Fold m a (Maybe Int)
forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> Step s b) -> Step s b -> (s -> b) -> Fold m a b
foldt' Int -> a -> Step Int (Maybe Int)
forall {s}. Num s => s -> a -> Step s (Maybe s)
step (Int -> Step Int (Maybe Int)
forall s b. s -> Step s b
Partial Int
0) (Maybe Int -> Int -> Maybe Int
forall a b. a -> b -> a
const Maybe Int
forall a. Maybe a
Nothing)
where
step :: s -> a -> Step s (Maybe s)
step s
i a
a =
if a -> Bool
predicate a
a
then Maybe s -> Step s (Maybe s)
forall s b. b -> Step s b
Done (Maybe s -> Step s (Maybe s)) -> Maybe s -> Step s (Maybe s)
forall a b. (a -> b) -> a -> b
$ s -> Maybe s
forall a. a -> Maybe a
Just s
i
else s -> Step s (Maybe s)
forall s b. s -> Step s b
Partial (s
i s -> s -> s
forall a. Num a => a -> a -> a
+ s
1)
{-# INLINE findIndices #-}
findIndices :: Monad m => (a -> Bool) -> Fold m a (Maybe Int)
findIndices :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Fold m a (Maybe Int)
findIndices = Scanl m a (Maybe Int) -> Fold m a (Maybe Int)
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a (Maybe Int) -> Fold m a (Maybe Int))
-> ((a -> Bool) -> Scanl m a (Maybe Int))
-> (a -> Bool)
-> Fold m a (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Bool) -> Scanl m a (Maybe Int)
forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Scanl m a (Maybe Int)
Scanl.findIndices
{-# INLINE elemIndices #-}
elemIndices :: (Monad m, Eq a) => a -> Fold m a (Maybe Int)
elemIndices :: forall (m :: * -> *) a.
(Monad m, Eq a) =>
a -> Fold m a (Maybe Int)
elemIndices = Scanl m a (Maybe Int) -> Fold m a (Maybe Int)
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a (Maybe Int) -> Fold m a (Maybe Int))
-> (a -> Scanl m a (Maybe Int)) -> a -> Fold m a (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Scanl m a (Maybe Int)
forall (m :: * -> *) a.
(Monad m, Eq a) =>
a -> Scanl m a (Maybe Int)
Scanl.elemIndices
{-# INLINE 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 = (a -> Bool) -> Fold m a (Maybe Int)
forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Fold m a (Maybe Int)
findIndex (a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
a)
{-# INLINE null #-}
null :: Monad m => Fold m a Bool
null :: forall (m :: * -> *) a. Monad m => Fold m a Bool
null = (() -> a -> Step () Bool)
-> Step () Bool -> (() -> Bool) -> Fold m a Bool
forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> Step s b) -> Step s b -> (s -> b) -> Fold m a b
foldt' (\() a
_ -> Bool -> Step () Bool
forall s b. b -> Step s b
Done Bool
False) (() -> Step () Bool
forall s b. s -> Step s b
Partial ()) (Bool -> () -> Bool
forall a b. a -> b -> a
const Bool
True)
{-# INLINE 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 = (Bool -> a -> Step Bool Bool)
-> Step Bool Bool -> (Bool -> Bool) -> Fold m a Bool
forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> Step s b) -> Step s b -> (s -> b) -> Fold m a b
foldt' Bool -> a -> Step Bool Bool
forall {p}. p -> a -> Step Bool Bool
step Step Bool Bool
forall {b}. Step Bool b
initial Bool -> Bool
forall a. a -> a
id
where
initial :: Step Bool b
initial = Bool -> Step Bool b
forall s b. s -> Step s b
Partial Bool
False
step :: p -> a -> Step Bool Bool
step p
_ a
a =
if a -> Bool
predicate a
a
then Bool -> Step Bool Bool
forall s b. b -> Step s b
Done Bool
True
else Bool -> Step Bool Bool
forall s b. s -> Step s b
Partial Bool
False
{-# INLINE 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 = (a -> Bool) -> Fold m a Bool
forall (m :: * -> *) a. Monad m => (a -> Bool) -> Fold m a Bool
any (a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
a)
{-# INLINE 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 = (Bool -> a -> Step Bool Bool)
-> Step Bool Bool -> (Bool -> Bool) -> Fold m a Bool
forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> Step s b) -> Step s b -> (s -> b) -> Fold m a b
foldt' Bool -> a -> Step Bool Bool
forall {p}. p -> a -> Step Bool Bool
step Step Bool Bool
forall {b}. Step Bool b
initial Bool -> Bool
forall a. a -> a
id
where
initial :: Step Bool b
initial = Bool -> Step Bool b
forall s b. s -> Step s b
Partial Bool
True
step :: p -> a -> Step Bool Bool
step p
_ a
a =
if a -> Bool
predicate a
a
then Bool -> Step Bool Bool
forall s b. s -> Step s b
Partial Bool
True
else Bool -> Step Bool Bool
forall s b. b -> Step s b
Done Bool
False
{-# INLINE 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 = (a -> Bool) -> Fold m a Bool
forall (m :: * -> *) a. Monad m => (a -> Bool) -> Fold m a Bool
all (a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/= a
a)
{-# INLINE and #-}
and :: Monad m => Fold m Bool Bool
and :: forall (m :: * -> *). Monad m => Fold m Bool Bool
and = (Bool -> Bool) -> Fold m Bool Bool
forall (m :: * -> *) a. Monad m => (a -> Bool) -> Fold m a Bool
all Bool -> Bool
forall a. a -> a
id
{-# INLINE or #-}
or :: Monad m => Fold m Bool Bool
or :: forall (m :: * -> *). Monad m => Fold m Bool Bool
or = (Bool -> Bool) -> Fold m Bool Bool
forall (m :: * -> *) a. Monad m => (a -> Bool) -> Fold m a Bool
any Bool -> Bool
forall a. a -> a
id
{-# 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 m a b
fld = (b -> c -> (b, c)) -> Fold m a b -> Fold m a c -> Fold m a (b, c)
forall (m :: * -> *) a b c x.
Monad m =>
(a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
splitWith (,) (Int -> Fold m a b -> Fold m a b
forall (m :: * -> *) a b.
Monad m =>
Int -> Fold m a b -> Fold m a b
take Int
n Fold m a b
fld)
{-# INLINE takingEndByM #-}
takingEndByM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
takingEndByM :: forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Fold m a (Maybe a)
takingEndByM a -> m Bool
p = (Maybe' a -> a -> m (Step (Maybe' a) (Maybe a)))
-> m (Step (Maybe' a) (Maybe a))
-> (Maybe' a -> m (Maybe a))
-> (Maybe' a -> m (Maybe a))
-> Fold m a (Maybe a)
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
Fold Maybe' a -> a -> m (Step (Maybe' a) (Maybe a))
forall {p}. p -> a -> m (Step (Maybe' a) (Maybe a))
step m (Step (Maybe' a) (Maybe a))
forall {a} {b}. m (Step (Maybe' a) b)
initial Maybe' a -> m (Maybe a)
forall {a}. Maybe' a -> m (Maybe a)
extract Maybe' a -> m (Maybe a)
forall {a}. Maybe' a -> m (Maybe a)
extract
where
initial :: m (Step (Maybe' a) b)
initial = Step (Maybe' a) b -> m (Step (Maybe' a) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe' a) b -> m (Step (Maybe' a) b))
-> Step (Maybe' a) b -> m (Step (Maybe' a) b)
forall a b. (a -> b) -> a -> b
$ Maybe' a -> Step (Maybe' a) b
forall s b. s -> Step s b
Partial Maybe' a
forall a. Maybe' a
Nothing'
step :: p -> a -> m (Step (Maybe' a) (Maybe a))
step p
_ a
a = do
Bool
r <- a -> m Bool
p a
a
Step (Maybe' a) (Maybe a) -> m (Step (Maybe' a) (Maybe a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
(Step (Maybe' a) (Maybe a) -> m (Step (Maybe' a) (Maybe a)))
-> Step (Maybe' a) (Maybe a) -> m (Step (Maybe' a) (Maybe a))
forall a b. (a -> b) -> a -> b
$ if Bool
r
then Maybe a -> Step (Maybe' a) (Maybe a)
forall s b. b -> Step s b
Done (Maybe a -> Step (Maybe' a) (Maybe a))
-> Maybe a -> Step (Maybe' a) (Maybe a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe a
forall a. a -> Maybe a
Just a
a
else Maybe' a -> Step (Maybe' a) (Maybe a)
forall s b. s -> Step s b
Partial (Maybe' a -> Step (Maybe' a) (Maybe a))
-> Maybe' a -> Step (Maybe' a) (Maybe a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe' a
forall a. a -> Maybe' a
Just' a
a
extract :: Maybe' a -> m (Maybe a)
extract = Maybe a -> m (Maybe a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe a -> m (Maybe a))
-> (Maybe' a -> Maybe a) -> Maybe' a -> m (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe' a -> Maybe a
forall a. Maybe' a -> Maybe a
toMaybe
{-# INLINE takingEndBy #-}
takingEndBy :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
takingEndBy :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Fold m a (Maybe a)
takingEndBy a -> Bool
p = (a -> m Bool) -> Fold m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Fold m a (Maybe a)
takingEndByM (Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> m Bool) -> (a -> Bool) -> a -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
p)
{-# INLINE takingEndByM_ #-}
takingEndByM_ :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
takingEndByM_ :: forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Fold m a (Maybe a)
takingEndByM_ a -> m Bool
p = (Maybe' a -> a -> m (Step (Maybe' a) (Maybe a)))
-> m (Step (Maybe' a) (Maybe a))
-> (Maybe' a -> m (Maybe a))
-> (Maybe' a -> m (Maybe a))
-> Fold m a (Maybe a)
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
Fold Maybe' a -> a -> m (Step (Maybe' a) (Maybe a))
forall {p} {a}. p -> a -> m (Step (Maybe' a) (Maybe a))
step m (Step (Maybe' a) (Maybe a))
forall {a} {b}. m (Step (Maybe' a) b)
initial Maybe' a -> m (Maybe a)
forall {a}. Maybe' a -> m (Maybe a)
extract Maybe' a -> m (Maybe a)
forall {a}. Maybe' a -> m (Maybe a)
extract
where
initial :: m (Step (Maybe' a) b)
initial = Step (Maybe' a) b -> m (Step (Maybe' a) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe' a) b -> m (Step (Maybe' a) b))
-> Step (Maybe' a) b -> m (Step (Maybe' a) b)
forall a b. (a -> b) -> a -> b
$ Maybe' a -> Step (Maybe' a) b
forall s b. s -> Step s b
Partial Maybe' a
forall a. Maybe' a
Nothing'
step :: p -> a -> m (Step (Maybe' a) (Maybe a))
step p
_ a
a = do
Bool
r <- a -> m Bool
p a
a
Step (Maybe' a) (Maybe a) -> m (Step (Maybe' a) (Maybe a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
(Step (Maybe' a) (Maybe a) -> m (Step (Maybe' a) (Maybe a)))
-> Step (Maybe' a) (Maybe a) -> m (Step (Maybe' a) (Maybe a))
forall a b. (a -> b) -> a -> b
$ if Bool
r
then Maybe a -> Step (Maybe' a) (Maybe a)
forall s b. b -> Step s b
Done Maybe a
forall a. Maybe a
Nothing
else Maybe' a -> Step (Maybe' a) (Maybe a)
forall s b. s -> Step s b
Partial (Maybe' a -> Step (Maybe' a) (Maybe a))
-> Maybe' a -> Step (Maybe' a) (Maybe a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe' a
forall a. a -> Maybe' a
Just' a
a
extract :: Maybe' a -> m (Maybe a)
extract = Maybe a -> m (Maybe a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe a -> m (Maybe a))
-> (Maybe' a -> Maybe a) -> Maybe' a -> m (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe' a -> Maybe a
forall a. Maybe' a -> Maybe a
toMaybe
{-# INLINE takingEndBy_ #-}
takingEndBy_ :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
takingEndBy_ :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Fold m a (Maybe a)
takingEndBy_ a -> Bool
p = (a -> m Bool) -> Fold m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Fold m a (Maybe a)
takingEndByM_ (Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> m Bool) -> (a -> Bool) -> a -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
p)
{-# INLINE droppingWhileM #-}
droppingWhileM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
droppingWhileM :: forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Fold m a (Maybe a)
droppingWhileM a -> m Bool
p = (Maybe' a -> a -> m (Step (Maybe' a) (Maybe a)))
-> m (Step (Maybe' a) (Maybe a))
-> (Maybe' a -> m (Maybe a))
-> (Maybe' a -> m (Maybe a))
-> Fold m a (Maybe a)
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
Fold Maybe' a -> a -> m (Step (Maybe' a) (Maybe a))
forall {a} {b}. Maybe' a -> a -> m (Step (Maybe' a) b)
step m (Step (Maybe' a) (Maybe a))
forall {a} {b}. m (Step (Maybe' a) b)
initial Maybe' a -> m (Maybe a)
forall {a}. Maybe' a -> m (Maybe a)
extract Maybe' a -> m (Maybe a)
forall {a}. Maybe' a -> m (Maybe a)
extract
where
initial :: m (Step (Maybe' a) b)
initial = Step (Maybe' a) b -> m (Step (Maybe' a) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe' a) b -> m (Step (Maybe' a) b))
-> Step (Maybe' a) b -> m (Step (Maybe' a) b)
forall a b. (a -> b) -> a -> b
$ Maybe' a -> Step (Maybe' a) b
forall s b. s -> Step s b
Partial Maybe' a
forall a. Maybe' a
Nothing'
step :: Maybe' a -> a -> m (Step (Maybe' a) b)
step Maybe' a
Nothing' a
a = do
Bool
r <- a -> m Bool
p a
a
Step (Maybe' a) b -> m (Step (Maybe' a) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
(Step (Maybe' a) b -> m (Step (Maybe' a) b))
-> Step (Maybe' a) b -> m (Step (Maybe' a) b)
forall a b. (a -> b) -> a -> b
$ Maybe' a -> Step (Maybe' a) b
forall s b. s -> Step s b
Partial
(Maybe' a -> Step (Maybe' a) b) -> Maybe' a -> Step (Maybe' a) b
forall a b. (a -> b) -> a -> b
$ if Bool
r
then Maybe' a
forall a. Maybe' a
Nothing'
else a -> Maybe' a
forall a. a -> Maybe' a
Just' a
a
step Maybe' a
_ a
a = Step (Maybe' a) b -> m (Step (Maybe' a) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Maybe' a) b -> m (Step (Maybe' a) b))
-> Step (Maybe' a) b -> m (Step (Maybe' a) b)
forall a b. (a -> b) -> a -> b
$ Maybe' a -> Step (Maybe' a) b
forall s b. s -> Step s b
Partial (Maybe' a -> Step (Maybe' a) b) -> Maybe' a -> Step (Maybe' a) b
forall a b. (a -> b) -> a -> b
$ a -> Maybe' a
forall a. a -> Maybe' a
Just' a
a
extract :: Maybe' a -> m (Maybe a)
extract = Maybe a -> m (Maybe a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe a -> m (Maybe a))
-> (Maybe' a -> Maybe a) -> Maybe' a -> m (Maybe a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe' a -> Maybe a
forall a. Maybe' a -> Maybe a
toMaybe
{-# INLINE droppingWhile #-}
droppingWhile :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
droppingWhile :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Fold m a (Maybe a)
droppingWhile a -> Bool
p = (a -> m Bool) -> Fold m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> m Bool) -> Fold m a (Maybe a)
droppingWhileM (Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> m Bool) -> (a -> Bool) -> a -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
p)
data SplitOnSeqState mba acc a rh w ck =
SplitOnSeqEmpty !acc
| SplitOnSeqSingle !acc !a
| SplitOnSeqWord !acc !Int !w
| SplitOnSeqWordLoop !acc !w
| SplitOnSeqKR !acc !Int !mba
| SplitOnSeqKRLoop !acc !ck !mba !rh
{-# INLINE takeEndBySeq #-}
takeEndBySeq :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) =>
Array.Array a
-> Fold m a b
-> Fold m a b
takeEndBySeq :: forall (m :: * -> *) a b.
(MonadIO m, Unbox a, Enum a, Eq a) =>
Array a -> Fold m a b -> Fold m a b
takeEndBySeq Array a
patArr (Fold s -> a -> m (Step s b)
fstep m (Step s b)
finitial s -> m b
fextract s -> m b
ffinal) =
(SplitOnSeqState MutByteArray s a Int Word Word32
-> a
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> (SplitOnSeqState MutByteArray s a Int Word Word32 -> m b)
-> (SplitOnSeqState MutByteArray s a Int Word Word32 -> m b)
-> Fold m a b
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
Fold SplitOnSeqState MutByteArray s a Int Word Word32
-> a
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
step m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall {rh} {ck}.
m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
initial SplitOnSeqState MutByteArray s a Int Word Word32 -> m b
forall {mba} {a} {rh} {w} {ck}.
SplitOnSeqState mba s a rh w ck -> m b
extract SplitOnSeqState MutByteArray s a Int Word Word32 -> m b
forall {mba} {a} {rh} {w} {ck}.
SplitOnSeqState mba s a rh w ck -> m b
final
where
patLen :: Int
patLen = Array a -> Int
forall a. Unbox a => Array a -> Int
Array.length Array a
patArr
patBytes :: Int
patBytes = Array a -> Int
forall a. Array a -> Int
Array.byteLength Array a
patArr
maxIndex :: Int
maxIndex = Int
patLen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
maxOffset :: Int
maxOffset = Int
patBytes Int -> Int -> Int
forall a. Num a => a -> a -> a
- SIZE_OF(a)
initial :: m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
initial = do
Step s b
res <- m (Step s b)
finitial
case Step s b
res of
Partial s
acc
| Int
patLen Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 ->
Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b))
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
-> SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall a b. (a -> b) -> a -> b
$ s -> SplitOnSeqState MutByteArray s a rh Word ck
forall mba acc a rh w ck. acc -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqEmpty s
acc
| Int
patLen Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 -> do
a
pat <- IO a -> m a
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> m a) -> IO a -> m a
forall a b. (a -> b) -> a -> b
$ Int -> Array a -> IO a
forall a. Unbox a => Int -> Array a -> IO a
Array.unsafeGetIndexIO Int
0 Array a
patArr
Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b))
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
-> SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall a b. (a -> b) -> a -> b
$ s -> a -> SplitOnSeqState MutByteArray s a rh Word ck
forall mba acc a rh w ck.
acc -> a -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqSingle s
acc a
pat
| SIZE_OF(a) * patLen <= sizeOf (Proxy :: Proxy Word) ->
Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b))
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
-> SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall a b. (a -> b) -> a -> b
$ s -> Int -> Word -> SplitOnSeqState MutByteArray s a rh Word ck
forall mba acc a rh w ck.
acc -> Int -> w -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqWord s
acc Int
0 Word
0
| Bool
otherwise -> do
(MutArray MutByteArray
mba Int
_ Int
_ Int
_) :: MutArray a <-
IO (MutArray a) -> m (MutArray a)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (MutArray a) -> m (MutArray a))
-> IO (MutArray a) -> m (MutArray a)
forall a b. (a -> b) -> a -> b
$ Int -> IO (MutArray a)
forall (m :: * -> *) a.
(MonadIO m, Unbox a) =>
Int -> m (MutArray a)
MA.emptyOf Int
patLen
Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b))
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
-> SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall a b. (a -> b) -> a -> b
$ s
-> Int
-> MutByteArray
-> SplitOnSeqState MutByteArray s a rh Word ck
forall mba acc a rh w ck.
acc -> Int -> mba -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqKR s
acc Int
0 MutByteArray
mba
Done b
b -> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b))
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall s b. b -> Step s b
Done b
b
elemBits :: Int
elemBits = SIZE_OF(a) * 8
wordMask :: Word
wordMask :: Word
wordMask = (Word
1 Word -> Int -> Word
forall a. Bits a => a -> Int -> a
`shiftL` (Int
elemBits Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
patLen)) Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1
wordPat :: Word
wordPat :: Word
wordPat = Word
wordMask Word -> Word -> Word
forall a. Bits a => a -> a -> a
.&. (Word -> a -> Word) -> Word -> Array a -> Word
forall a b. Unbox a => (b -> a -> b) -> b -> Array a -> b
Array.foldl' Word -> a -> Word
forall {a} {a}. (Bits a, Num a, Enum a) => a -> a -> a
addToWord Word
0 Array a
patArr
addToWord :: a -> a -> a
addToWord a
wd a
a = (a
wd a -> Int -> a
forall a. Bits a => a -> Int -> a
`shiftL` Int
elemBits) a -> a -> a
forall a. Bits a => a -> a -> a
.|. Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a -> Int
forall a. Enum a => a -> Int
fromEnum a
a)
k :: Word32
k = Word32
2891336453 :: Word32
coeff :: Word32
coeff = Word32
k Word32 -> Int -> Word32
forall a b. (Num a, Integral b) => a -> b -> a
^ Int
patLen
addCksum :: Word32 -> a -> Word32
addCksum Word32
cksum a
a = Word32
cksum Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Word32
k Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
+ Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a -> Int
forall a. Enum a => a -> Int
fromEnum a
a)
deltaCksum :: Word32 -> a -> a -> Word32
deltaCksum Word32
cksum a
old a
new =
Word32 -> a -> Word32
forall {a}. Enum a => Word32 -> a -> Word32
addCksum Word32
cksum a
new Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
coeff Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a -> Int
forall a. Enum a => a -> Int
fromEnum a
old)
patHash :: Word32
patHash = (Word32 -> a -> Word32) -> Word32 -> Array a -> Word32
forall a b. Unbox a => (b -> a -> b) -> b -> Array a -> b
Array.foldl' Word32 -> a -> Word32
forall {a}. Enum a => Word32 -> a -> Word32
addCksum Word32
0 Array a
patArr
step :: SplitOnSeqState MutByteArray s a Int Word Word32
-> a
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
step (SplitOnSeqEmpty s
s) a
x = do
Step s b
res <- s -> a -> m (Step s b)
fstep s
s a
x
case Step s b
res of
Partial s
s1 -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s -> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck. acc -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqEmpty s
s1
Done b
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done b
b
step (SplitOnSeqSingle s
s a
pat) a
x = do
Step s b
res <- s -> a -> m (Step s b)
fstep s
s a
x
case Step s b
res of
Partial s
s1
| a
pat a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/= a
x -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s -> a -> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> a -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqSingle s
s1 a
pat
| Bool
otherwise -> b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done (b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> m b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s1
Done b
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done b
b
step (SplitOnSeqWord s
s Int
idx Word
wrd) a
x = do
Step s b
res <- s -> a -> m (Step s b)
fstep s
s a
x
let wrd1 :: Word
wrd1 = Word -> a -> Word
forall {a} {a}. (Bits a, Num a, Enum a) => a -> a -> a
addToWord Word
wrd a
x
case Step s b
res of
Partial s
s1
| Int
idx Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
maxIndex -> do
if Word
wrd1 Word -> Word -> Word
forall a. Bits a => a -> a -> a
.&. Word
wordMask Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
wordPat
then b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done (b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> m b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s1
else Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s -> Word -> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> w -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqWordLoop s
s1 Word
wrd1
| Bool
otherwise ->
Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s
-> Int -> Word -> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> Int -> w -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqWord s
s1 (Int
idx Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Word
wrd1
Done b
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done b
b
step (SplitOnSeqWordLoop s
s Word
wrd) a
x = do
Step s b
res <- s -> a -> m (Step s b)
fstep s
s a
x
let wrd1 :: Word
wrd1 = Word -> a -> Word
forall {a} {a}. (Bits a, Num a, Enum a) => a -> a -> a
addToWord Word
wrd a
x
case Step s b
res of
Partial s
s1
| Word
wrd1 Word -> Word -> Word
forall a. Bits a => a -> a -> a
.&. Word
wordMask Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
wordPat ->
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done (b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> m b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s1
| Bool
otherwise ->
Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s -> Word -> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> w -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqWordLoop s
s1 Word
wrd1
Done b
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done b
b
step (SplitOnSeqKR s
s Int
offset MutByteArray
mba) a
x = do
Step s b
res <- s -> a -> m (Step s b)
fstep s
s a
x
case Step s b
res of
Partial s
s1 -> do
IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Int -> MutByteArray -> a -> IO ()
forall a. Unbox a => Int -> MutByteArray -> a -> IO ()
pokeAt Int
offset MutByteArray
mba a
x
if Int
offset Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
maxOffset
then do
let Array a
arr :: Array a = Array
{ arrContents :: MutByteArray
arrContents = MutByteArray
mba
, arrStart :: Int
arrStart = Int
0
, arrEnd :: Int
arrEnd = Int
patBytes
}
let ringHash :: Word32
ringHash = (Word32 -> a -> Word32) -> Word32 -> Array a -> Word32
forall a b. Unbox a => (b -> a -> b) -> b -> Array a -> b
Array.foldl' Word32 -> a -> Word32
forall {a}. Enum a => Word32 -> a -> Word32
addCksum Word32
0 Array a
arr
if Word32
ringHash Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
patHash Bool -> Bool -> Bool
&& Array a -> Array a -> Bool
forall a. Array a -> Array a -> Bool
Array.byteEq Array a
arr Array a
patArr
then b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done (b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> m b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s1
else Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s
-> Word32
-> MutByteArray
-> Int
-> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> ck -> mba -> rh -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqKRLoop s
s1 Word32
ringHash MutByteArray
mba Int
0
else
Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s
-> Int
-> MutByteArray
-> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> Int -> mba -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqKR s
s1 (Int
offset Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SIZE_OF(a)) mba
Done b
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done b
b
step (SplitOnSeqKRLoop s
s Word32
cksum MutByteArray
mba Int
offset) a
x = do
Step s b
res <- s -> a -> m (Step s b)
fstep s
s a
x
case Step s b
res of
Partial s
s1 -> do
let rb :: RingArray a
rb = RingArray
{ ringContents :: MutByteArray
ringContents = MutByteArray
mba
, ringSize :: Int
ringSize = Int
patBytes
, ringHead :: Int
ringHead = Int
offset
}
(RingArray a
rb1, a
old :: a) <- IO (RingArray a, a) -> m (RingArray a, a)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (RingArray a -> a -> IO (RingArray a, a)
forall (m :: * -> *) a.
(MonadIO m, Unbox a) =>
RingArray a -> a -> m (RingArray a, a)
RingArray.replace RingArray a
forall {a}. RingArray a
rb a
x)
let ringHash :: Word32
ringHash = Word32 -> a -> a -> Word32
forall {a} {a}. (Enum a, Enum a) => Word32 -> a -> a -> Word32
deltaCksum Word32
cksum a
old a
x
let rh1 :: Int
rh1 = RingArray a -> Int
forall a. RingArray a -> Int
ringHead RingArray a
rb1
Bool
matches <-
if Word32
ringHash Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
patHash
then IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ RingArray a -> Array a -> IO Bool
forall a. RingArray a -> Array a -> IO Bool
RingArray.eqArray RingArray a
rb1 Array a
patArr
else Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
if Bool
matches
then b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done (b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> m b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s1
else Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s
-> Word32
-> MutByteArray
-> Int
-> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> ck -> mba -> rh -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqKRLoop s
s1 Word32
ringHash MutByteArray
mba Int
rh1
Done b
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done b
b
extractFunc :: (t -> t) -> SplitOnSeqState mba t a rh w ck -> t
extractFunc t -> t
fex SplitOnSeqState mba t a rh w ck
state =
let st :: t
st =
case SplitOnSeqState mba t a rh w ck
state of
SplitOnSeqEmpty t
s -> t
s
SplitOnSeqSingle t
s a
_ -> t
s
SplitOnSeqWord t
s Int
_ w
_ -> t
s
SplitOnSeqWordLoop t
s w
_ -> t
s
SplitOnSeqKR t
s Int
_ mba
_ -> t
s
SplitOnSeqKRLoop t
s ck
_ mba
_ rh
_ -> t
s
in t -> t
fex t
st
extract :: SplitOnSeqState mba s a rh w ck -> m b
extract = (s -> m b) -> SplitOnSeqState mba s a rh w ck -> m b
forall {t} {t} {mba} {a} {rh} {w} {ck}.
(t -> t) -> SplitOnSeqState mba t a rh w ck -> t
extractFunc s -> m b
fextract
final :: SplitOnSeqState mba s a rh w ck -> m b
final = (s -> m b) -> SplitOnSeqState mba s a rh w ck -> m b
forall {t} {t} {mba} {a} {rh} {w} {ck}.
(t -> t) -> SplitOnSeqState mba t a rh w ck -> t
extractFunc s -> m b
ffinal
{-# INLINE takeEndBySeq_ #-}
takeEndBySeq_ :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) =>
Array.Array a
-> Fold m a b
-> Fold m a b
takeEndBySeq_ :: forall (m :: * -> *) a b.
(MonadIO m, Unbox a, Enum a, Eq a) =>
Array a -> Fold m a b -> Fold m a b
takeEndBySeq_ Array a
patArr (Fold s -> a -> m (Step s b)
fstep m (Step s b)
finitial s -> m b
fextract s -> m b
ffinal) =
(SplitOnSeqState MutByteArray s a Int Word Word32
-> a
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> (SplitOnSeqState MutByteArray s a Int Word Word32 -> m b)
-> (SplitOnSeqState MutByteArray s a Int Word Word32 -> m b)
-> Fold m a b
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
Fold SplitOnSeqState MutByteArray s a Int Word Word32
-> a
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
step m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall {rh} {ck}.
m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
initial SplitOnSeqState MutByteArray s a Int Word Word32 -> m b
forall {a} {ck}.
SplitOnSeqState MutByteArray s a Int Word ck -> m b
extract SplitOnSeqState MutByteArray s a Int Word Word32 -> m b
forall {a} {ck}.
SplitOnSeqState MutByteArray s a Int Word ck -> m b
final
where
patLen :: Int
patLen = Array a -> Int
forall a. Unbox a => Array a -> Int
Array.length Array a
patArr
patBytes :: Int
patBytes = Array a -> Int
forall a. Array a -> Int
Array.byteLength Array a
patArr
maxIndex :: Int
maxIndex = Int
patLen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
maxOffset :: Int
maxOffset = Int
patBytes Int -> Int -> Int
forall a. Num a => a -> a -> a
- SIZE_OF(a)
initial :: m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
initial = do
Step s b
res <- m (Step s b)
finitial
case Step s b
res of
Partial s
acc
| Int
patLen Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 ->
Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b))
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
-> SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall a b. (a -> b) -> a -> b
$ s -> SplitOnSeqState MutByteArray s a rh Word ck
forall mba acc a rh w ck. acc -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqEmpty s
acc
| Int
patLen Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 -> do
a
pat <- IO a -> m a
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> m a) -> IO a -> m a
forall a b. (a -> b) -> a -> b
$ Int -> Array a -> IO a
forall a. Unbox a => Int -> Array a -> IO a
Array.unsafeGetIndexIO Int
0 Array a
patArr
Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b))
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
-> SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall a b. (a -> b) -> a -> b
$ s -> a -> SplitOnSeqState MutByteArray s a rh Word ck
forall mba acc a rh w ck.
acc -> a -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqSingle s
acc a
pat
| SIZE_OF(a) * patLen <= sizeOf (Proxy :: Proxy Word) ->
Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b))
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
-> SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall a b. (a -> b) -> a -> b
$ s -> Int -> Word -> SplitOnSeqState MutByteArray s a rh Word ck
forall mba acc a rh w ck.
acc -> Int -> w -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqWord s
acc Int
0 Word
0
| Bool
otherwise -> do
(MutArray MutByteArray
mba Int
_ Int
_ Int
_) :: MutArray a <-
IO (MutArray a) -> m (MutArray a)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (MutArray a) -> m (MutArray a))
-> IO (MutArray a) -> m (MutArray a)
forall a b. (a -> b) -> a -> b
$ Int -> IO (MutArray a)
forall (m :: * -> *) a.
(MonadIO m, Unbox a) =>
Int -> m (MutArray a)
MA.emptyOf Int
patLen
Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b))
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
-> SplitOnSeqState MutByteArray s a rh Word ck
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall a b. (a -> b) -> a -> b
$ s
-> Int
-> MutByteArray
-> SplitOnSeqState MutByteArray s a rh Word ck
forall mba acc a rh w ck.
acc -> Int -> mba -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqKR s
acc Int
0 MutByteArray
mba
Done b
b -> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b))
-> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
-> m (Step (SplitOnSeqState MutByteArray s a rh Word ck) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a rh Word ck) b
forall s b. b -> Step s b
Done b
b
elemBits :: Int
elemBits = SIZE_OF(a) * 8
wordMask :: Word
wordMask :: Word
wordMask = (Word
1 Word -> Int -> Word
forall a. Bits a => a -> Int -> a
`shiftL` (Int
elemBits Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
patLen)) Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1
elemMask :: Word
elemMask :: Word
elemMask = (Word
1 Word -> Int -> Word
forall a. Bits a => a -> Int -> a
`shiftL` Int
elemBits) Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1
wordPat :: Word
wordPat :: Word
wordPat = Word
wordMask Word -> Word -> Word
forall a. Bits a => a -> a -> a
.&. (Word -> a -> Word) -> Word -> Array a -> Word
forall a b. Unbox a => (b -> a -> b) -> b -> Array a -> b
Array.foldl' Word -> a -> Word
forall {a} {a}. (Bits a, Num a, Enum a) => a -> a -> a
addToWord Word
0 Array a
patArr
addToWord :: a -> a -> a
addToWord a
wd a
a = (a
wd a -> Int -> a
forall a. Bits a => a -> Int -> a
`shiftL` Int
elemBits) a -> a -> a
forall a. Bits a => a -> a -> a
.|. Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a -> Int
forall a. Enum a => a -> Int
fromEnum a
a)
k :: Word32
k = Word32
2891336453 :: Word32
coeff :: Word32
coeff = Word32
k Word32 -> Int -> Word32
forall a b. (Num a, Integral b) => a -> b -> a
^ Int
patLen
addCksum :: Word32 -> a -> Word32
addCksum Word32
cksum a
a = Word32
cksum Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Word32
k Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
+ Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a -> Int
forall a. Enum a => a -> Int
fromEnum a
a)
deltaCksum :: Word32 -> a -> a -> Word32
deltaCksum Word32
cksum a
old a
new =
Word32 -> a -> Word32
forall {a}. Enum a => Word32 -> a -> Word32
addCksum Word32
cksum a
new Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
coeff Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
* Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a -> Int
forall a. Enum a => a -> Int
fromEnum a
old)
patHash :: Word32
patHash = (Word32 -> a -> Word32) -> Word32 -> Array a -> Word32
forall a b. Unbox a => (b -> a -> b) -> b -> Array a -> b
Array.foldl' Word32 -> a -> Word32
forall {a}. Enum a => Word32 -> a -> Word32
addCksum Word32
0 Array a
patArr
step :: SplitOnSeqState MutByteArray s a Int Word Word32
-> a
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
step (SplitOnSeqEmpty s
s) a
x = do
Step s b
res <- s -> a -> m (Step s b)
fstep s
s a
x
case Step s b
res of
Partial s
s1 -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s -> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck. acc -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqEmpty s
s1
Done b
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done b
b
step (SplitOnSeqSingle s
s a
pat) a
x = do
if a
pat a -> a -> Bool
forall a. Eq a => a -> a -> Bool
/= a
x
then do
Step s b
res <- s -> a -> m (Step s b)
fstep s
s a
x
case Step s b
res of
Partial s
s1 -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s -> a -> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> a -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqSingle s
s1 a
pat
Done b
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done b
b
else b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done (b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> m b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s
step (SplitOnSeqWord s
s Int
idx Word
wrd) a
x = do
let wrd1 :: Word
wrd1 = Word -> a -> Word
forall {a} {a}. (Bits a, Num a, Enum a) => a -> a -> a
addToWord Word
wrd a
x
if Int
idx Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
maxIndex
then do
if Word
wrd1 Word -> Word -> Word
forall a. Bits a => a -> a -> a
.&. Word
wordMask Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
wordPat
then b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done (b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> m b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s
else Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s -> Word -> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> w -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqWordLoop s
s Word
wrd1
else Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s
-> Int -> Word -> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> Int -> w -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqWord s
s (Int
idx Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Word
wrd1
step (SplitOnSeqWordLoop s
s Word
wrd) a
x = do
let wrd1 :: Word
wrd1 = Word -> a -> Word
forall {a} {a}. (Bits a, Num a, Enum a) => a -> a -> a
addToWord Word
wrd a
x
old :: Word
old = (Word
wordMask Word -> Word -> Word
forall a. Bits a => a -> a -> a
.&. Word
wrd)
Word -> Int -> Word
forall a. Bits a => a -> Int -> a
`shiftR` (Int
elemBits Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
patLen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1))
Step s b
res <- s -> a -> m (Step s b)
fstep s
s (Int -> a
forall a. Enum a => Int -> a
toEnum (Int -> a) -> Int -> a
forall a b. (a -> b) -> a -> b
$ Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
old)
case Step s b
res of
Partial s
s1
| Word
wrd1 Word -> Word -> Word
forall a. Bits a => a -> a -> a
.&. Word
wordMask Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
wordPat ->
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done (b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> m b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s1
| Bool
otherwise ->
Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s -> Word -> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> w -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqWordLoop s
s1 Word
wrd1
Done b
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done b
b
step (SplitOnSeqKR s
s Int
offset MutByteArray
mba) a
x = do
IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Int -> MutByteArray -> a -> IO ()
forall a. Unbox a => Int -> MutByteArray -> a -> IO ()
pokeAt Int
offset MutByteArray
mba a
x
if Int
offset Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
maxOffset
then do
let Array a
arr :: Array a = Array
{ arrContents :: MutByteArray
arrContents = MutByteArray
mba
, arrStart :: Int
arrStart = Int
0
, arrEnd :: Int
arrEnd = Int
patBytes
}
let ringHash :: Word32
ringHash = (Word32 -> a -> Word32) -> Word32 -> Array a -> Word32
forall a b. Unbox a => (b -> a -> b) -> b -> Array a -> b
Array.foldl' Word32 -> a -> Word32
forall {a}. Enum a => Word32 -> a -> Word32
addCksum Word32
0 Array a
arr
if Word32
ringHash Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
patHash Bool -> Bool -> Bool
&& Array a -> Array a -> Bool
forall a. Array a -> Array a -> Bool
Array.byteEq Array a
arr Array a
patArr
then b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done (b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> m b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s
else Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s
-> Word32
-> MutByteArray
-> Int
-> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> ck -> mba -> rh -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqKRLoop s
s Word32
ringHash MutByteArray
mba Int
0
else Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s
-> Int
-> MutByteArray
-> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> Int -> mba -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqKR s
s (Int
offset Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SIZE_OF(a)) mba
step (SplitOnSeqKRLoop s
s Word32
cksum MutByteArray
mba Int
offset) a
x = do
let rb :: RingArray a
rb = RingArray
{ ringContents :: MutByteArray
ringContents = MutByteArray
mba
, ringSize :: Int
ringSize = Int
patBytes
, ringHead :: Int
ringHead = Int
offset
}
(RingArray a
rb1, a
old :: a) <- IO (RingArray a, a) -> m (RingArray a, a)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (RingArray a -> a -> IO (RingArray a, a)
forall (m :: * -> *) a.
(MonadIO m, Unbox a) =>
RingArray a -> a -> m (RingArray a, a)
RingArray.replace RingArray a
forall {a}. RingArray a
rb a
x)
Step s b
res <- s -> a -> m (Step s b)
fstep s
s a
old
case Step s b
res of
Partial s
s1 -> do
let ringHash :: Word32
ringHash = Word32 -> a -> a -> Word32
forall {a} {a}. (Enum a, Enum a) => Word32 -> a -> a -> Word32
deltaCksum Word32
cksum a
old a
x
let rh1 :: Int
rh1 = RingArray a -> Int
forall a. RingArray a -> Int
ringHead RingArray a
rb1
Bool
matches <-
if Word32
ringHash Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
patHash
then IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ RingArray a -> Array a -> IO Bool
forall a. RingArray a -> Array a -> IO Bool
RingArray.eqArray RingArray a
rb1 Array a
patArr
else Bool -> m Bool
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
if Bool
matches
then b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done (b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> m b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s1
else Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. s -> Step s b
Partial (SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
-> SplitOnSeqState MutByteArray s a Int Word Word32
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall a b. (a -> b) -> a -> b
$ s
-> Word32
-> MutByteArray
-> Int
-> SplitOnSeqState MutByteArray s a Int Word Word32
forall mba acc a rh w ck.
acc -> ck -> mba -> rh -> SplitOnSeqState mba acc a rh w ck
SplitOnSeqKRLoop s
s1 Word32
ringHash MutByteArray
mba Int
rh1
Done b
b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b))
-> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
-> m (Step (SplitOnSeqState MutByteArray s a Int Word Word32) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (SplitOnSeqState MutByteArray s a Int Word Word32) b
forall s b. b -> Step s b
Done b
b
extractFunc :: (s -> m b) -> SplitOnSeqState MutByteArray s a Int Word ck -> m b
extractFunc s -> m b
fex SplitOnSeqState MutByteArray s a Int Word ck
state = do
let consumeWord :: s -> Int -> Word -> m b
consumeWord s
s Int
n Word
wrd = do
if Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
then s -> m b
fex s
s
else do
let old :: Word
old = Word
elemMask Word -> Word -> Word
forall a. Bits a => a -> a -> a
.&. (Word
wrd Word -> Int -> Word
forall a. Bits a => a -> Int -> a
`shiftR` (Int
elemBits Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)))
Step s b
r <- s -> a -> m (Step s b)
fstep s
s (Int -> a
forall a. Enum a => Int -> a
toEnum (Int -> a) -> Int -> a
forall a b. (a -> b) -> a -> b
$ Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
old)
case Step s b
r of
Partial s
s1 -> s -> Int -> Word -> m b
consumeWord s
s1 (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Word
wrd
Done b
b -> b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return b
b
let consumeArray :: s -> Int -> MutByteArray -> Int -> m b
consumeArray s
s Int
end MutByteArray
mba Int
offset =
if Int
offset Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
end
then s -> m b
fex s
s
else do
a
old <- IO a -> m a
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> m a) -> IO a -> m a
forall a b. (a -> b) -> a -> b
$ Int -> MutByteArray -> IO a
forall a. Unbox a => Int -> MutByteArray -> IO a
peekAt Int
offset MutByteArray
mba
Step s b
r <- s -> a -> m (Step s b)
fstep s
s a
old
case Step s b
r of
Partial s
s1 ->
s -> Int -> MutByteArray -> Int -> m b
consumeArray s
s1 Int
end MutByteArray
mba (Int
offset Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SIZE_OF(a))
Done b
b -> b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return b
b
let consumeRing :: s -> Int -> MutByteArray -> Int -> m b
consumeRing s
s Int
orig MutByteArray
mba Int
offset = do
let RingArray a
rb :: RingArray a = RingArray
{ ringContents :: MutByteArray
ringContents = MutByteArray
mba
, ringSize :: Int
ringSize = Int
patBytes
, ringHead :: Int
ringHead = Int
offset
}
a
old <- RingArray a -> m a
forall (m :: * -> *) a. (MonadIO m, Unbox a) => RingArray a -> m a
RingArray.unsafeGetHead RingArray a
rb
let rb1 :: RingArray a
rb1 = RingArray a -> RingArray a
forall a. Unbox a => RingArray a -> RingArray a
RingArray.moveForward RingArray a
rb
Step s b
r <- s -> a -> m (Step s b)
fstep s
s a
old
case Step s b
r of
Partial s
s1 ->
let rh :: Int
rh = RingArray a -> Int
forall a. RingArray a -> Int
ringHead RingArray a
rb1
in if Int
rh Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
orig
then s -> m b
fex s
s1
else s -> Int -> MutByteArray -> Int -> m b
consumeRing s
s1 Int
orig MutByteArray
mba Int
rh
Done b
b -> b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return b
b
case SplitOnSeqState MutByteArray s a Int Word ck
state of
SplitOnSeqEmpty s
s -> s -> m b
fex s
s
SplitOnSeqSingle s
s a
_ -> s -> m b
fex s
s
SplitOnSeqWord s
s Int
idx Word
wrd -> s -> Int -> Word -> m b
consumeWord s
s Int
idx Word
wrd
SplitOnSeqWordLoop s
s Word
wrd -> s -> Int -> Word -> m b
consumeWord s
s Int
patLen Word
wrd
SplitOnSeqKR s
s Int
end MutByteArray
mba -> s -> Int -> MutByteArray -> Int -> m b
consumeArray s
s Int
end MutByteArray
mba Int
0
SplitOnSeqKRLoop s
s ck
_ MutByteArray
mba Int
rh -> s -> Int -> MutByteArray -> Int -> m b
consumeRing s
s Int
rh MutByteArray
mba Int
rh
extract :: SplitOnSeqState MutByteArray s a Int Word ck -> m b
extract = (s -> m b) -> SplitOnSeqState MutByteArray s a Int Word ck -> m b
forall {a} {ck}.
(s -> m b) -> SplitOnSeqState MutByteArray s a Int Word ck -> m b
extractFunc s -> m b
fextract
final :: SplitOnSeqState MutByteArray s a Int Word ck -> m b
final = (s -> m b) -> SplitOnSeqState MutByteArray s a Int Word ck -> m b
forall {a} {ck}.
(s -> m b) -> SplitOnSeqState MutByteArray s a Int Word ck -> m b
extractFunc s -> m b
ffinal
{-# 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 = (b -> c -> (b, c)) -> Fold m a b -> Fold m a c -> Fold m a (b, c)
forall (m :: * -> *) a b c x.
Monad m =>
(a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
teeWith (,)
{-# 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 = (Fold m a b -> Fold m a [b] -> Fold m a [b])
-> Fold m a [b] -> [Fold m a b] -> Fold m a [b]
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr ((b -> [b] -> [b]) -> Fold m a b -> Fold m a [b] -> Fold m a [b]
forall (m :: * -> *) a b c x.
Monad m =>
(a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
teeWith (:)) ([b] -> Fold m a [b]
forall (m :: * -> *) b a. Applicative m => b -> Fold m a b
fromPure [])
{-# INLINE distributeScan #-}
distributeScan :: Monad m => m [Fold m a b] -> Scanl m a [b]
distributeScan :: forall (m :: * -> *) a b.
Monad m =>
m [Fold m a b] -> Scanl m a [b]
distributeScan m [Fold m a b]
getFolds = (Tuple' [Fold m a b] [b]
-> a -> m (Step (Tuple' [Fold m a b] [b]) [b]))
-> m (Step (Tuple' [Fold m a b] [b]) [b])
-> (Tuple' [Fold m a b] [b] -> m [b])
-> (Tuple' [Fold m a b] [b] -> m [b])
-> Scanl m a [b]
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Scanl m a b
Scanl Tuple' [Fold m a b] [b]
-> a -> m (Step (Tuple' [Fold m a b] [b]) [b])
forall {b} {b}.
Tuple' [Fold m a b] b -> a -> m (Step (Tuple' [Fold m a b] [b]) b)
consume m (Step (Tuple' [Fold m a b] [b]) [b])
forall {a} {a} {b}. m (Step (Tuple' [a] [a]) b)
initial Tuple' [Fold m a b] [b] -> m [b]
forall {m :: * -> *} {a} {a}. Monad m => Tuple' a a -> m a
extract Tuple' [Fold m a b] [b] -> m [b]
forall {t :: * -> *} {m :: * -> *} {a} {b} {b}.
(Foldable t, Monad m) =>
Tuple' (t (Fold m a b)) b -> m b
final
where
initial :: m (Step (Tuple' [a] [a]) b)
initial = Step (Tuple' [a] [a]) b -> m (Step (Tuple' [a] [a]) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Tuple' [a] [a]) b -> m (Step (Tuple' [a] [a]) b))
-> Step (Tuple' [a] [a]) b -> m (Step (Tuple' [a] [a]) b)
forall a b. (a -> b) -> a -> b
$ Tuple' [a] [a] -> Step (Tuple' [a] [a]) b
forall s b. s -> Step s b
Partial ([a] -> [a] -> Tuple' [a] [a]
forall a b. a -> b -> Tuple' a b
Tuple' [] [])
run :: Tuple' [Fold m a b] [b]
-> [Fold m a b] -> a -> m (Step (Tuple' [Fold m a b] [b]) b)
run Tuple' [Fold m a b] [b]
st [] a
_ = Step (Tuple' [Fold m a b] [b]) b
-> m (Step (Tuple' [Fold m a b] [b]) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Tuple' [Fold m a b] [b]) b
-> m (Step (Tuple' [Fold m a b] [b]) b))
-> Step (Tuple' [Fold m a b] [b]) b
-> m (Step (Tuple' [Fold m a b] [b]) b)
forall a b. (a -> b) -> a -> b
$ Tuple' [Fold m a b] [b] -> Step (Tuple' [Fold m a b] [b]) b
forall s b. s -> Step s b
Partial Tuple' [Fold m a b] [b]
st
run (Tuple' [Fold m a b]
ys [b]
zs) (Fold s -> a -> m (Step s b)
step m (Step s b)
init s -> m b
extr s -> m b
fin : [Fold m a b]
xs) a
a = do
Step s b
res <- m (Step s b)
init
case Step s b
res of
Partial s
fs -> do
Step s b
r <- s -> a -> m (Step s b)
step s
fs a
a
Tuple' [Fold m a b] [b]
-> [Fold m a b] -> a -> m (Step (Tuple' [Fold m a b] [b]) b)
run ([Fold m a b] -> [b] -> Tuple' [Fold m a b] [b]
forall a b. a -> b -> Tuple' a b
Tuple' ((s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
Fold s -> a -> m (Step s b)
step (Step s b -> m (Step s b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Step s b
r) s -> m b
extr s -> m b
fin Fold m a b -> [Fold m a b] -> [Fold m a b]
forall a. a -> [a] -> [a]
: [Fold m a b]
ys) [b]
zs) [Fold m a b]
xs a
a
Done b
b -> do
Tuple' [Fold m a b] [b]
-> [Fold m a b] -> a -> m (Step (Tuple' [Fold m a b] [b]) b)
run ([Fold m a b] -> [b] -> Tuple' [Fold m a b] [b]
forall a b. a -> b -> Tuple' a b
Tuple' [Fold m a b]
ys (b
b b -> [b] -> [b]
forall a. a -> [a] -> [a]
: [b]
zs)) [Fold m a b]
xs a
a
consume :: Tuple' [Fold m a b] b -> a -> m (Step (Tuple' [Fold m a b] [b]) b)
consume (Tuple' [Fold m a b]
st b
_) a
x = do
[Fold m a b]
xs <- m [Fold m a b]
getFolds
[Fold m a b]
xs1 <- (Fold m a b -> m (Fold m a b)) -> [Fold m a b] -> m [Fold m a b]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
Prelude.mapM Fold m a b -> m (Fold m a b)
forall (m :: * -> *) a b. Monad m => Fold m a b -> m (Fold m a b)
reduce [Fold m a b]
xs
let st1 :: [Fold m a b]
st1 = [Fold m a b]
st [Fold m a b] -> [Fold m a b] -> [Fold m a b]
forall a. [a] -> [a] -> [a]
++ [Fold m a b]
xs1
Tuple' [Fold m a b] [b]
-> [Fold m a b] -> a -> m (Step (Tuple' [Fold m a b] [b]) b)
forall {m :: * -> *} {a} {b} {b}.
Monad m =>
Tuple' [Fold m a b] [b]
-> [Fold m a b] -> a -> m (Step (Tuple' [Fold m a b] [b]) b)
run ([Fold m a b] -> [b] -> Tuple' [Fold m a b] [b]
forall a b. a -> b -> Tuple' a b
Tuple' [] []) [Fold m a b]
st1 a
x
extract :: Tuple' a a -> m a
extract (Tuple' a
_ a
done) = a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
done
final :: Tuple' (t (Fold m a b)) b -> m b
final (Tuple' t (Fold m a b)
st b
done) = do
(Fold m a b -> m b) -> t (Fold m a b) -> m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
Prelude.mapM_ Fold m a b -> m b
forall (m :: * -> *) a b. Monad m => Fold m a b -> m b
finalM t (Fold m a b)
st
b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return b
done
{-# INLINE partitionByMUsing #-}
partitionByMUsing :: Monad m =>
( (x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y)
)
-> (a -> m (Either b c))
-> Fold m b x
-> Fold m c y
-> Fold m a (x, y)
partitionByMUsing :: forall (m :: * -> *) x y b c a.
Monad m =>
((x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y))
-> (a -> m (Either b c))
-> Fold m b x
-> Fold m c y
-> Fold m a (x, y)
partitionByMUsing (x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y)
t a -> m (Either b c)
f Fold m b x
fld1 Fold m c y
fld2 =
let l :: Fold m (Either b b) x
l = (Either b b -> b) -> Fold m b x -> Fold m (Either b b) x
forall a b (m :: * -> *) r. (a -> b) -> Fold m b r -> Fold m a r
lmap (b -> Either b b -> b
forall a b. a -> Either a b -> a
fromLeft b
forall a. HasCallStack => a
undefined) Fold m b x
fld1
r :: Fold m (Either a c) y
r = (Either a c -> c) -> Fold m c y -> Fold m (Either a c) y
forall a b (m :: * -> *) r. (a -> b) -> Fold m b r -> Fold m a r
lmap (c -> Either a c -> c
forall b a. b -> Either a b -> b
fromRight c
forall a. HasCallStack => a
undefined) Fold m c y
fld2
in (a -> m (Either b c))
-> Fold m (Either b c) (x, y) -> Fold m a (x, y)
forall (m :: * -> *) a b r.
Monad m =>
(a -> m b) -> Fold m b r -> Fold m a r
lmapM a -> m (Either b c)
f ((x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y)
t (,) ((Either b c -> Bool)
-> Fold m (Either b c) x -> Fold m (Either b c) x
forall (m :: * -> *) a r.
Monad m =>
(a -> Bool) -> Fold m a r -> Fold m a r
filter Either b c -> Bool
forall a b. Either a b -> Bool
isLeft Fold m (Either b c) x
forall {b}. Fold m (Either b b) x
l) ((Either b c -> Bool)
-> Fold m (Either b c) y -> Fold m (Either b c) y
forall (m :: * -> *) a r.
Monad m =>
(a -> Bool) -> Fold m a r -> Fold m a r
filter Either b c -> Bool
forall a b. Either a b -> Bool
isRight Fold m (Either b c) y
forall {a}. Fold m (Either a c) y
r))
{-# 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 = ((x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y))
-> (a -> m (Either b c))
-> Fold m b x
-> Fold m c y
-> Fold m a (x, y)
forall (m :: * -> *) x y b c a.
Monad m =>
((x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y))
-> (a -> m (Either b c))
-> Fold m b x
-> Fold m c y
-> Fold m a (x, y)
partitionByMUsing (x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y)
forall (m :: * -> *) a b c x.
Monad m =>
(a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
teeWith
{-# INLINE partitionByFstM #-}
partitionByFstM :: Monad m
=> (a -> m (Either b c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
partitionByFstM :: 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)
partitionByFstM = ((x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y))
-> (a -> m (Either b c))
-> Fold m b x
-> Fold m c y
-> Fold m a (x, y)
forall (m :: * -> *) x y b c a.
Monad m =>
((x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y))
-> (a -> m (Either b c))
-> Fold m b x
-> Fold m c y
-> Fold m a (x, y)
partitionByMUsing (x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y)
forall (m :: * -> *) a b c x.
Monad m =>
(a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
teeWithFst
{-# INLINE partitionByMinM #-}
partitionByMinM :: Monad m =>
(a -> m (Either b c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
partitionByMinM :: 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)
partitionByMinM = ((x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y))
-> (a -> m (Either b c))
-> Fold m b x
-> Fold m c y
-> Fold m a (x, y)
forall (m :: * -> *) x y b c a.
Monad m =>
((x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y))
-> (a -> m (Either b c))
-> Fold m b x
-> Fold m c y
-> Fold m a (x, y)
partitionByMUsing (x -> y -> (x, y))
-> Fold m (Either b c) x
-> Fold m (Either b c) y
-> Fold m (Either b c) (x, y)
forall (m :: * -> *) a b c x.
Monad m =>
(a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
teeWithMin
{-# 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 = (a -> m (Either b c))
-> Fold m b x -> Fold m c y -> Fold m a (x, y)
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 (Either b c -> m (Either b c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either b c -> m (Either b c))
-> (a -> Either b c) -> a -> m (Either b c)
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 = (Either b c -> Either b c)
-> Fold m b x -> Fold m c y -> Fold m (Either b c) (x, y)
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 Either b c -> Either b c
forall a. a -> a
id
{-# INLINE unzipWithMUsing #-}
unzipWithMUsing :: Monad m =>
( (x -> y -> (x, y))
-> Fold m (b, c) x
-> Fold m (b, c) y
-> Fold m (b, c) (x, y)
)
-> (a -> m (b, c))
-> Fold m b x
-> Fold m c y
-> Fold m a (x, y)
unzipWithMUsing :: forall (m :: * -> *) x y b c a.
Monad m =>
((x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y))
-> (a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
unzipWithMUsing (x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y)
t a -> m (b, c)
f Fold m b x
fld1 Fold m c y
fld2 =
let f1 :: Fold m (b, b) x
f1 = ((b, b) -> b) -> Fold m b x -> Fold m (b, b) x
forall a b (m :: * -> *) r. (a -> b) -> Fold m b r -> Fold m a r
lmap (b, b) -> b
forall a b. (a, b) -> a
fst Fold m b x
fld1
f2 :: Fold m (a, c) y
f2 = ((a, c) -> c) -> Fold m c y -> Fold m (a, c) y
forall a b (m :: * -> *) r. (a -> b) -> Fold m b r -> Fold m a r
lmap (a, c) -> c
forall a b. (a, b) -> b
snd Fold m c y
fld2
in (a -> m (b, c)) -> Fold m (b, c) (x, y) -> Fold m a (x, y)
forall (m :: * -> *) a b r.
Monad m =>
(a -> m b) -> Fold m b r -> Fold m a r
lmapM a -> m (b, c)
f ((x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y)
t (,) Fold m (b, c) x
forall {b}. Fold m (b, b) x
f1 Fold m (b, c) y
forall {a}. Fold m (a, c) y
f2)
{-# 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 = ((x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y))
-> (a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
forall (m :: * -> *) x y b c a.
Monad m =>
((x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y))
-> (a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
unzipWithMUsing (x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y)
forall (m :: * -> *) a b c x.
Monad m =>
(a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
teeWith
{-# INLINE unzipWithFstM #-}
unzipWithFstM :: Monad m =>
(a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
unzipWithFstM :: 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)
unzipWithFstM = ((x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y))
-> (a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
forall (m :: * -> *) x y b c a.
Monad m =>
((x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y))
-> (a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
unzipWithMUsing (x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y)
forall (m :: * -> *) a b c x.
Monad m =>
(a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
teeWithFst
{-# INLINE unzipWithMinM #-}
unzipWithMinM :: Monad m =>
(a -> m (b,c)) -> Fold m b x -> Fold m c y -> Fold m a (x,y)
unzipWithMinM :: 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)
unzipWithMinM = ((x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y))
-> (a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
forall (m :: * -> *) x y b c a.
Monad m =>
((x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y))
-> (a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
unzipWithMUsing (x -> y -> (x, y))
-> Fold m (b, c) x -> Fold m (b, c) y -> Fold m (b, c) (x, y)
forall (m :: * -> *) a b c x.
Monad m =>
(a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
teeWithMin
{-# 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 = (a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
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 ((b, c) -> m (b, c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ((b, c) -> m (b, c)) -> (a -> (b, c)) -> a -> m (b, c)
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 = ((a, b) -> (a, b))
-> Fold m a x -> Fold m b y -> Fold m (a, b) (x, y)
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) -> (a, b)
forall a. a -> a
id
{-# INLINE zipStreamWithM #-}
zipStreamWithM ::
(a -> b -> m c) -> Stream m a -> Fold m c x -> Fold m b x
zipStreamWithM :: forall a b (m :: * -> *) c x.
(a -> b -> m c) -> Stream m a -> Fold m c x -> Fold m b x
zipStreamWithM = (a -> b -> m c) -> Stream m a -> Fold m c x -> Fold m b x
forall a. HasCallStack => a
undefined
{-# INLINE zipStream #-}
zipStream :: Monad m => Stream m a -> Fold m (a, b) x -> Fold m b x
zipStream :: forall (m :: * -> *) a b x.
Monad m =>
Stream m a -> Fold m (a, b) x -> Fold m b x
zipStream = (a -> b -> m (a, b)) -> Stream m a -> Fold m (a, b) x -> Fold m b x
forall a b (m :: * -> *) c x.
(a -> b -> m c) -> Stream m a -> Fold m c x -> Fold m b x
zipStreamWithM (((a, b) -> m (a, b)) -> a -> b -> m (a, b)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry (a, b) -> m (a, b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return)
{-# DEPRECATED indexingWith "Use Scanl.indexingWith instead" #-}
{-# INLINE indexingWith #-}
indexingWith :: Monad m => Int -> (Int -> Int) -> Fold m a (Maybe (Int, a))
indexingWith :: forall (m :: * -> *) a.
Monad m =>
Int -> (Int -> Int) -> Fold m a (Maybe (Int, a))
indexingWith Int
i Int -> Int
f = (Maybe' (Int, a) -> Maybe (Int, a))
-> Fold m a (Maybe' (Int, a)) -> Fold m a (Maybe (Int, a))
forall a b. (a -> b) -> Fold m a a -> Fold m a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe' (Int, a) -> Maybe (Int, a)
forall a. Maybe' a -> Maybe a
toMaybe (Fold m a (Maybe' (Int, a)) -> Fold m a (Maybe (Int, a)))
-> Fold m a (Maybe' (Int, a)) -> Fold m a (Maybe (Int, a))
forall a b. (a -> b) -> a -> b
$ (Maybe' (Int, a) -> a -> Maybe' (Int, a))
-> Maybe' (Int, a) -> Fold m a (Maybe' (Int, a))
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Fold m a b
foldl' Maybe' (Int, a) -> a -> Maybe' (Int, a)
forall {b} {b}. Maybe' (Int, b) -> b -> Maybe' (Int, b)
step Maybe' (Int, a)
forall a. Maybe' a
initial
where
initial :: Maybe' a
initial = Maybe' a
forall a. Maybe' a
Nothing'
step :: Maybe' (Int, b) -> b -> Maybe' (Int, b)
step Maybe' (Int, b)
Nothing' b
a = (Int, b) -> Maybe' (Int, b)
forall a. a -> Maybe' a
Just' (Int
i, b
a)
step (Just' (Int
n, b
_)) b
a = (Int, b) -> Maybe' (Int, b)
forall a. a -> Maybe' a
Just' (Int -> Int
f Int
n, b
a)
{-# DEPRECATED indexing "Use Scanl.indexing instead" #-}
{-# INLINE indexing #-}
indexing :: Monad m => Fold m a (Maybe (Int, a))
indexing :: forall (m :: * -> *) a. Monad m => Fold m a (Maybe (Int, a))
indexing = Int -> (Int -> Int) -> Fold m a (Maybe (Int, a))
forall (m :: * -> *) a.
Monad m =>
Int -> (Int -> Int) -> Fold m a (Maybe (Int, a))
indexingWith Int
0 (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
{-# DEPRECATED indexingRev "Use Scanl.indexingRev instead" #-}
{-# INLINE indexingRev #-}
indexingRev :: Monad m => Int -> Fold m a (Maybe (Int, a))
indexingRev :: forall (m :: * -> *) a. Monad m => Int -> Fold m a (Maybe (Int, a))
indexingRev Int
n = Int -> (Int -> Int) -> Fold m a (Maybe (Int, a))
forall (m :: * -> *) a.
Monad m =>
Int -> (Int -> Int) -> Fold m a (Maybe (Int, a))
indexingWith Int
n (Int -> Int -> Int
forall a. Num a => a -> a -> a
subtract Int
1)
{-# INLINE indexed #-}
indexed :: Monad m => Fold m (Int, a) b -> Fold m a b
indexed :: forall (m :: * -> *) a b.
Monad m =>
Fold m (Int, a) b -> Fold m a b
indexed = Scanl m a (Maybe (Int, a)) -> Fold m (Int, a) b -> Fold m a b
forall (m :: * -> *) a b c.
Monad m =>
Scanl m a (Maybe b) -> Fold m b c -> Fold m a c
postscanlMaybe Scanl m a (Maybe (Int, a))
forall (m :: * -> *) a. Monad m => Scanl m a (Maybe (Int, a))
Scanl.indexing
{-# INLINE with #-}
with ::
(Fold m (s, a) b -> Fold m a b)
-> (((s, a) -> c) -> Fold m (s, a) b -> Fold m (s, a) b)
-> (((s, a) -> c) -> Fold m a b -> Fold m a b)
with :: forall (m :: * -> *) s a b c.
(Fold m (s, a) b -> Fold m a b)
-> (((s, a) -> c) -> Fold m (s, a) b -> Fold m (s, a) b)
-> ((s, a) -> c)
-> Fold m a b
-> Fold m a b
with Fold m (s, a) b -> Fold m a b
f ((s, a) -> c) -> Fold m (s, a) b -> Fold m (s, a) b
comb (s, a) -> c
g = Fold m (s, a) b -> Fold m a b
f (Fold m (s, a) b -> Fold m a b)
-> (Fold m a b -> Fold m (s, a) b) -> Fold m a b -> Fold m a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((s, a) -> c) -> Fold m (s, a) b -> Fold m (s, a) b
comb (s, a) -> c
g (Fold m (s, a) b -> Fold m (s, a) b)
-> (Fold m a b -> Fold m (s, a) b) -> Fold m a b -> Fold m (s, a) b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((s, a) -> a) -> Fold m a b -> Fold m (s, a) b
forall a b (m :: * -> *) r. (a -> b) -> Fold m b r -> Fold m a r
lmap (s, a) -> a
forall a b. (a, b) -> b
snd
{-# INLINE sampleFromthen #-}
sampleFromthen :: Monad m => Int -> Int -> Fold m a b -> Fold m a b
sampleFromthen :: forall (m :: * -> *) a b.
Monad m =>
Int -> Int -> Fold m a b -> Fold m a b
sampleFromthen Int
offset Int
size =
(Fold m (Int, a) b -> Fold m a b)
-> (((Int, a) -> Bool) -> Fold m (Int, a) b -> Fold m (Int, a) b)
-> ((Int, a) -> Bool)
-> Fold m a b
-> Fold m a b
forall (m :: * -> *) s a b c.
(Fold m (s, a) b -> Fold m a b)
-> (((s, a) -> c) -> Fold m (s, a) b -> Fold m (s, a) b)
-> ((s, a) -> c)
-> Fold m a b
-> Fold m a b
with Fold m (Int, a) b -> Fold m a b
forall (m :: * -> *) a b.
Monad m =>
Fold m (Int, a) b -> Fold m a b
indexed ((Int, a) -> Bool) -> Fold m (Int, a) b -> Fold m (Int, a) b
forall (m :: * -> *) a r.
Monad m =>
(a -> Bool) -> Fold m a r -> Fold m a r
filter (\(Int
i, a
_) -> (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
offset) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` Int
size Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0)
{-# INLINE concatSequence #-}
concatSequence ::
Fold m b c -> t (Fold m a b) -> Fold m a c
concatSequence :: forall (m :: * -> *) b c (t :: * -> *) a.
Fold m b c -> t (Fold m a b) -> Fold m a c
concatSequence Fold m b c
_f t (Fold m a b)
_p = Fold m a c
forall a. HasCallStack => a
undefined
{-# INLINE chunksBetween #-}
chunksBetween ::
Int -> Int -> Fold m a b -> Fold m b c -> Fold m a c
chunksBetween :: forall (m :: * -> *) a b c.
Int -> Int -> Fold m a b -> Fold m b c -> Fold m a c
chunksBetween Int
_low Int
_high Fold m a b
_f1 Fold m b c
_f2 = Fold m a c
forall a. HasCallStack => a
undefined
{-# INLINE toStream #-}
toStream :: (Monad m, Monad n) => Fold m a (Stream n a)
toStream :: forall (m :: * -> *) (n :: * -> *) a.
(Monad m, Monad n) =>
Fold m a (Stream n a)
toStream = Scanl m a (Stream n a) -> Fold m a (Stream n a)
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl Scanl m a (Stream n a)
forall (m :: * -> *) (n :: * -> *) a.
(Monad m, Monad n) =>
Scanl m a (Stream n a)
Scanl.toStream
{-# INLINE toStreamRev #-}
toStreamRev :: (Monad m, Monad n) => Fold m a (Stream n a)
toStreamRev :: forall (m :: * -> *) (n :: * -> *) a.
(Monad m, Monad n) =>
Fold m a (Stream n a)
toStreamRev = Scanl m a (Stream n a) -> Fold m a (Stream n a)
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl Scanl m a (Stream n a)
forall (m :: * -> *) (n :: * -> *) a.
(Monad m, Monad n) =>
Scanl m a (Stream n a)
Scanl.toStreamRev
{-# INLINE unfoldMany #-}
unfoldMany :: Monad m => Unfold m a b -> Fold m b c -> Fold m a c
unfoldMany :: forall (m :: * -> *) a b c.
Monad m =>
Unfold m a b -> Fold m b c -> Fold m a c
unfoldMany (Unfold s -> m (Step s b)
ustep a -> m s
inject) (Fold s -> b -> m (Step s c)
fstep m (Step s c)
initial s -> m c
extract s -> m c
final) =
(s -> a -> m (Step s c))
-> m (Step s c) -> (s -> m c) -> (s -> m c) -> Fold m a c
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
Fold s -> a -> m (Step s c)
consume m (Step s c)
initial s -> m c
extract s -> m c
final
where
{-# INLINE produce #-}
produce :: s -> s -> m (Step s c)
produce s
fs s
us = do
Step s b
ures <- s -> m (Step s b)
ustep s
us
case Step s b
ures of
StreamD.Yield b
b s
us1 -> do
Step s c
fres <- s -> b -> m (Step s c)
fstep s
fs b
b
case Step s c
fres of
Partial s
fs1 -> s -> s -> m (Step s c)
produce s
fs1 s
us1
Done c
c -> Step s c -> m (Step s c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step s c -> m (Step s c)) -> Step s c -> m (Step s c)
forall a b. (a -> b) -> a -> b
$ c -> Step s c
forall s b. b -> Step s b
Done c
c
StreamD.Skip s
us1 -> s -> s -> m (Step s c)
produce s
fs s
us1
Step s b
StreamD.Stop -> Step s c -> m (Step s c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step s c -> m (Step s c)) -> Step s c -> m (Step s c)
forall a b. (a -> b) -> a -> b
$ s -> Step s c
forall s b. s -> Step s b
Partial s
fs
{-# INLINE_LATE consume #-}
consume :: s -> a -> m (Step s c)
consume s
s a
a = a -> m s
inject a
a m s -> (s -> m (Step s c)) -> m (Step s c)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= s -> s -> m (Step s c)
produce s
s
{-# INLINE bottomBy #-}
bottomBy :: (MonadIO m, Unbox a) =>
(a -> a -> Ordering)
-> Int
-> Fold m a (MutArray a)
bottomBy :: forall (m :: * -> *) a.
(MonadIO m, Unbox a) =>
(a -> a -> Ordering) -> Int -> Fold m a (MutArray a)
bottomBy a -> a -> Ordering
cmp = Scanl m a (MutArray a) -> Fold m a (MutArray a)
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a (MutArray a) -> Fold m a (MutArray a))
-> (Int -> Scanl m a (MutArray a)) -> Int -> Fold m a (MutArray a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> Ordering) -> Int -> Scanl m a (MutArray a)
forall (m :: * -> *) a.
(MonadIO m, Unbox a) =>
(a -> a -> Ordering) -> Int -> Scanl m a (MutArray a)
Scanl.bottomBy a -> a -> Ordering
cmp
{-# INLINE topBy #-}
topBy :: (MonadIO m, Unbox a) =>
(a -> a -> Ordering)
-> Int
-> Fold m a (MutArray a)
topBy :: forall (m :: * -> *) a.
(MonadIO m, Unbox a) =>
(a -> a -> Ordering) -> Int -> Fold m a (MutArray a)
topBy a -> a -> Ordering
cmp = (a -> a -> Ordering) -> Int -> Fold m a (MutArray a)
forall (m :: * -> *) a.
(MonadIO m, Unbox a) =>
(a -> a -> Ordering) -> Int -> Fold m a (MutArray a)
bottomBy ((a -> a -> Ordering) -> a -> a -> Ordering
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> a -> Ordering
cmp)
{-# INLINE top #-}
top :: (MonadIO m, Unbox a, Ord a) => Int -> Fold m a (MutArray a)
top :: forall (m :: * -> *) a.
(MonadIO m, Unbox a, Ord a) =>
Int -> Fold m a (MutArray a)
top = Scanl m a (MutArray a) -> Fold m a (MutArray a)
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a (MutArray a) -> Fold m a (MutArray a))
-> (Int -> Scanl m a (MutArray a)) -> Int -> Fold m a (MutArray a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Scanl m a (MutArray a)
forall (m :: * -> *) a.
(MonadIO m, Unbox a, Ord a) =>
Int -> Scanl m a (MutArray a)
Scanl.top
{-# INLINE bottom #-}
bottom :: (MonadIO m, Unbox a, Ord a) => Int -> Fold m a (MutArray a)
bottom :: forall (m :: * -> *) a.
(MonadIO m, Unbox a, Ord a) =>
Int -> Fold m a (MutArray a)
bottom = Scanl m a (MutArray a) -> Fold m a (MutArray a)
forall (m :: * -> *) a b. Scanl m a b -> Fold m a b
fromScanl (Scanl m a (MutArray a) -> Fold m a (MutArray a))
-> (Int -> Scanl m a (MutArray a)) -> Int -> Fold m a (MutArray a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Scanl m a (MutArray a)
forall (m :: * -> *) a.
(MonadIO m, Unbox a, Ord a) =>
Int -> Scanl m a (MutArray a)
Scanl.bottom
data IntersperseQState fs ps =
IntersperseQUnquoted !fs !ps
| IntersperseQQuoted !fs !ps
| IntersperseQQuotedEsc !fs !ps
{-# INLINE intersperseWithQuotes #-}
intersperseWithQuotes :: (Monad m, Eq a) =>
a -> a -> a -> Fold m a b -> Fold m b c -> Fold m a c
intersperseWithQuotes :: forall (m :: * -> *) a b c.
(Monad m, Eq a) =>
a -> a -> a -> Fold m a b -> Fold m b c -> Fold m a c
intersperseWithQuotes
a
quote
a
esc
a
separator
(Fold s -> a -> m (Step s b)
stepL m (Step s b)
initialL s -> m b
_ s -> m b
finalL)
(Fold s -> b -> m (Step s c)
stepR m (Step s c)
initialR s -> m c
extractR s -> m c
finalR) = (IntersperseQState s s -> a -> m (Step (IntersperseQState s s) c))
-> m (Step (IntersperseQState s s) c)
-> (IntersperseQState s s -> m c)
-> (IntersperseQState s s -> m c)
-> Fold m a c
forall (m :: * -> *) a b s.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
Fold IntersperseQState s s -> a -> m (Step (IntersperseQState s s) c)
step m (Step (IntersperseQState s s) c)
initial IntersperseQState s s -> m c
forall {ps}. IntersperseQState s ps -> m c
extract IntersperseQState s s -> m c
final
where
errMsg :: [Char] -> [Char] -> a
errMsg [Char]
p [Char]
status =
[Char] -> a
forall a. HasCallStack => [Char] -> a
error ([Char] -> a) -> [Char] -> a
forall a b. (a -> b) -> a -> b
$ [Char]
"intersperseWithQuotes: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
p [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" parsing fold cannot "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
status [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" without input"
{-# INLINE initL #-}
initL :: (s -> s) -> m (Step s b)
initL s -> s
mkState = do
Step s b
resL <- m (Step s b)
initialL
case Step s b
resL of
Partial s
sL ->
Step s b -> m (Step s b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step s b -> m (Step s b)) -> Step s b -> m (Step s b)
forall a b. (a -> b) -> a -> b
$ s -> Step s b
forall s b. s -> Step s b
Partial (s -> Step s b) -> s -> Step s b
forall a b. (a -> b) -> a -> b
$ s -> s
mkState s
sL
Done b
_ ->
[Char] -> [Char] -> m (Step s b)
forall {a}. [Char] -> [Char] -> a
errMsg [Char]
"content" [Char]
"succeed"
initial :: m (Step (IntersperseQState s s) c)
initial = do
Step s c
res <- m (Step s c)
initialR
case Step s c
res of
Partial s
sR -> (s -> IntersperseQState s s) -> m (Step (IntersperseQState s s) c)
forall {s} {b}. (s -> s) -> m (Step s b)
initL (s -> s -> IntersperseQState s s
forall fs ps. fs -> ps -> IntersperseQState fs ps
IntersperseQUnquoted s
sR)
Done c
b -> Step (IntersperseQState s s) c
-> m (Step (IntersperseQState s s) c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (IntersperseQState s s) c
-> m (Step (IntersperseQState s s) c))
-> Step (IntersperseQState s s) c
-> m (Step (IntersperseQState s s) c)
forall a b. (a -> b) -> a -> b
$ c -> Step (IntersperseQState s s) c
forall s b. b -> Step s b
Done c
b
{-# INLINE collect #-}
collect :: (s -> s -> s) -> s -> b -> m (Step s c)
collect s -> s -> s
nextS s
sR b
b = do
Step s c
res <- s -> b -> m (Step s c)
stepR s
sR b
b
case Step s c
res of
Partial s
s ->
(s -> s) -> m (Step s c)
forall {s} {b}. (s -> s) -> m (Step s b)
initL (s -> s -> s
nextS s
s)
Done c
c -> Step s c -> m (Step s c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (c -> Step s c
forall s b. b -> Step s b
Done c
c)
{-# INLINE process #-}
process :: a -> s -> s -> (s -> s -> s) -> m (Step s c)
process a
a s
sL s
sR s -> s -> s
nextState = do
Step s b
r <- s -> a -> m (Step s b)
stepL s
sL a
a
case Step s b
r of
Partial s
s -> Step s c -> m (Step s c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step s c -> m (Step s c)) -> Step s c -> m (Step s c)
forall a b. (a -> b) -> a -> b
$ s -> Step s c
forall s b. s -> Step s b
Partial (s -> s -> s
nextState s
sR s
s)
Done b
b -> (s -> s -> s) -> s -> b -> m (Step s c)
forall {s}. (s -> s -> s) -> s -> b -> m (Step s c)
collect s -> s -> s
nextState s
sR b
b
{-# INLINE processQuoted #-}
processQuoted :: a -> s -> s -> (s -> s -> s) -> m (Step s b)
processQuoted a
a s
sL s
sR s -> s -> s
nextState = do
Step s b
r <- s -> a -> m (Step s b)
stepL s
sL a
a
case Step s b
r of
Partial s
s -> Step s b -> m (Step s b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step s b -> m (Step s b)) -> Step s b -> m (Step s b)
forall a b. (a -> b) -> a -> b
$ s -> Step s b
forall s b. s -> Step s b
Partial (s -> s -> s
nextState s
sR s
s)
Done b
_ -> do
c
_ <- s -> m c
finalR s
sR
[Char] -> m (Step s b)
forall a. HasCallStack => [Char] -> a
error [Char]
"Collecting fold finished inside quote"
step :: IntersperseQState s s -> a -> m (Step (IntersperseQState s s) c)
step (IntersperseQUnquoted s
sR s
sL) a
a
| a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
separator = do
b
b <- s -> m b
finalL s
sL
(s -> s -> IntersperseQState s s)
-> s -> b -> m (Step (IntersperseQState s s) c)
forall {s}. (s -> s -> s) -> s -> b -> m (Step s c)
collect s -> s -> IntersperseQState s s
forall fs ps. fs -> ps -> IntersperseQState fs ps
IntersperseQUnquoted s
sR b
b
| a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
quote = a
-> s
-> s
-> (s -> s -> IntersperseQState s s)
-> m (Step (IntersperseQState s s) c)
forall {s} {b}. a -> s -> s -> (s -> s -> s) -> m (Step s b)
processQuoted a
a s
sL s
sR s -> s -> IntersperseQState s s
forall fs ps. fs -> ps -> IntersperseQState fs ps
IntersperseQQuoted
| Bool
otherwise = a
-> s
-> s
-> (s -> s -> IntersperseQState s s)
-> m (Step (IntersperseQState s s) c)
forall {s}. a -> s -> s -> (s -> s -> s) -> m (Step s c)
process a
a s
sL s
sR s -> s -> IntersperseQState s s
forall fs ps. fs -> ps -> IntersperseQState fs ps
IntersperseQUnquoted
step (IntersperseQQuoted s
sR s
sL) a
a
| a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
esc = a
-> s
-> s
-> (s -> s -> IntersperseQState s s)
-> m (Step (IntersperseQState s s) c)
forall {s} {b}. a -> s -> s -> (s -> s -> s) -> m (Step s b)
processQuoted a
a s
sL s
sR s -> s -> IntersperseQState s s
forall fs ps. fs -> ps -> IntersperseQState fs ps
IntersperseQQuotedEsc
| a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
quote = a
-> s
-> s
-> (s -> s -> IntersperseQState s s)
-> m (Step (IntersperseQState s s) c)
forall {s}. a -> s -> s -> (s -> s -> s) -> m (Step s c)
process a
a s
sL s
sR s -> s -> IntersperseQState s s
forall fs ps. fs -> ps -> IntersperseQState fs ps
IntersperseQUnquoted
| Bool
otherwise = a
-> s
-> s
-> (s -> s -> IntersperseQState s s)
-> m (Step (IntersperseQState s s) c)
forall {s} {b}. a -> s -> s -> (s -> s -> s) -> m (Step s b)
processQuoted a
a s
sL s
sR s -> s -> IntersperseQState s s
forall fs ps. fs -> ps -> IntersperseQState fs ps
IntersperseQQuoted
step (IntersperseQQuotedEsc s
sR s
sL) a
a =
a
-> s
-> s
-> (s -> s -> IntersperseQState s s)
-> m (Step (IntersperseQState s s) c)
forall {s} {b}. a -> s -> s -> (s -> s -> s) -> m (Step s b)
processQuoted a
a s
sL s
sR s -> s -> IntersperseQState s s
forall fs ps. fs -> ps -> IntersperseQState fs ps
IntersperseQQuoted
extract :: IntersperseQState s ps -> m c
extract (IntersperseQUnquoted s
sR ps
_) = s -> m c
extractR s
sR
extract (IntersperseQQuoted s
_ ps
_) =
[Char] -> m c
forall a. HasCallStack => [Char] -> a
error [Char]
"intersperseWithQuotes: finished inside quote"
extract (IntersperseQQuotedEsc s
_ ps
_) =
[Char] -> m c
forall a. HasCallStack => [Char] -> a
error [Char]
"intersperseWithQuotes: finished inside quote, at escape char"
final :: IntersperseQState s s -> m c
final (IntersperseQUnquoted s
sR s
sL) = s -> m b
finalL s
sL m b -> m c -> m c
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> s -> m c
finalR s
sR
final (IntersperseQQuoted s
sR s
sL) = do
c
_ <- s -> m c
finalR s
sR
b
_ <- s -> m b
finalL s
sL
[Char] -> m c
forall a. HasCallStack => [Char] -> a
error [Char]
"intersperseWithQuotes: finished inside quote"
final (IntersperseQQuotedEsc s
sR s
sL) = do
c
_ <- s -> m c
finalR s
sR
b
_ <- s -> m b
finalL s
sL
[Char] -> m c
forall a. HasCallStack => [Char] -> a
error [Char]
"intersperseWithQuotes: finished inside quote, at escape char"