{-# LANGUAGE CPP #-}
module Streamly.Internal.Data.Scanl.Type
(
module Streamly.Internal.Data.Fold.Step
, Scanl (..)
, mkScanl
, mkScanlM
, mkScanl1
, mkScanl1M
, mkScant
, mkScantM
, mkScanr
, mkScanrM
, const
, constM
, fromRefold
, drain
, latest
, functionM
, toList
, toStreamK
, toStreamKRev
, genericLength
, length
, maximumBy
, maximum
, minimumBy
, minimum
, rangeBy
, range
, rmapM
, lmap
, lmapM
, postscanl
, catMaybes
, postscanlMaybe
, filter
, filtering
, filterM
, catLefts
, catRights
, catEithers
, take
, taking
, takeEndBy_
, takeEndBy
, dropping
, teeWith
, morphInner
, generalizeInner
)
where
#include "inline.hs"
#if !MIN_VERSION_base(4,18,0)
import Control.Applicative (liftA2)
#endif
import Control.Monad ((>=>))
import Data.Either (fromLeft, fromRight, isLeft, isRight)
import Data.Functor ((<&>))
import Data.Functor.Identity (Identity(..))
import Fusion.Plugin.Types (Fuse(..))
import Streamly.Internal.Data.Maybe.Strict (Maybe'(..), toMaybe)
import Streamly.Internal.Data.Refold.Type (Refold(..))
import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))
import qualified Streamly.Internal.Data.StreamK.Type as K
import Prelude hiding (Foldable(..), concatMap, filter, map, take, const)
import Streamly.Internal.Data.Fold.Step
#include "DocTestDataScanl.hs"
data Scanl m a b =
forall s. Scanl (s -> a -> m (Step s b)) (m (Step s b)) (s -> m b) (s -> m b)
{-# INLINE rmapM #-}
rmapM :: Monad m => (b -> m c) -> Scanl m a b -> Scanl m a c
rmapM :: forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> Scanl m a b -> Scanl m a c
rmapM b -> m c
f (Scanl s -> a -> m (Step s b)
step m (Step s b)
initial s -> m b
extract s -> m b
final) =
(s -> a -> m (Step s c))
-> m (Step s c) -> (s -> m c) -> (s -> m c) -> Scanl m a c
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 s -> a -> m (Step s c)
step1 m (Step s c)
initial1 (s -> m b
extract (s -> m b) -> (b -> m c) -> s -> m c
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> b -> m c
f) (s -> m b
final (s -> m b) -> (b -> m c) -> s -> m c
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> b -> m c
f)
where
initial1 :: m (Step s c)
initial1 = m (Step s b)
initial m (Step s b) -> (Step s b -> 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
>>= (b -> m c) -> Step s b -> m (Step s c)
forall (m :: * -> *) a b s.
Applicative m =>
(a -> m b) -> Step s a -> m (Step s b)
mapMStep b -> m c
f
step1 :: s -> a -> m (Step s c)
step1 s
s a
a = s -> a -> m (Step s b)
step s
s a
a m (Step s b) -> (Step s b -> 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
>>= (b -> m c) -> Step s b -> m (Step s c)
forall (m :: * -> *) a b s.
Applicative m =>
(a -> m b) -> Step s a -> m (Step s b)
mapMStep b -> m c
f
{-# INLINE mkScanl #-}
mkScanl :: Monad m => (b -> a -> b) -> b -> Scanl m a b
mkScanl :: forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Scanl m a b
mkScanl b -> a -> b
step b
initial =
(b -> a -> m (Step b b))
-> m (Step b b) -> (b -> m 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
(\b
s a
a -> Step b b -> m (Step b b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step b b -> m (Step b b)) -> Step b b -> m (Step b b)
forall a b. (a -> b) -> a -> b
$ b -> Step b b
forall s b. s -> Step s b
Partial (b -> Step b b) -> b -> Step b b
forall a b. (a -> b) -> a -> b
$ b -> a -> b
step b
s a
a)
(Step b b -> m (Step b b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> Step b b
forall s b. s -> Step s b
Partial b
initial))
b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINE mkScanlM #-}
mkScanlM :: Monad m => (b -> a -> m b) -> m b -> Scanl m a b
mkScanlM :: forall (m :: * -> *) b a.
Monad m =>
(b -> a -> m b) -> m b -> Scanl m a b
mkScanlM b -> a -> m b
step m b
initial =
(b -> a -> m (Step b b))
-> m (Step b b) -> (b -> m 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 (\b
s a
a -> b -> Step b b
forall s b. s -> Step s b
Partial (b -> Step b b) -> m b -> m (Step b b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> a -> m b
step b
s a
a) (b -> Step b b
forall s b. s -> Step s b
Partial (b -> Step b b) -> m b -> m (Step b b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m b
initial) b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
instance Functor m => Functor (Scanl m a) where
{-# INLINE fmap #-}
fmap :: forall a b. (a -> b) -> Scanl m a a -> Scanl m a b
fmap a -> b
f (Scanl s -> a -> m (Step s a)
step1 m (Step s a)
initial1 s -> m a
extract s -> m a
final) =
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> 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 s -> a -> m (Step s b)
step m (Step s b)
initial ((a -> b) -> (s -> m a) -> s -> m b
forall {f :: * -> *} {f :: * -> *} {a} {b}.
(Functor f, Functor f) =>
(a -> b) -> f (f a) -> f (f b)
fmap2 a -> b
f s -> m a
extract) ((a -> b) -> (s -> m a) -> s -> m b
forall {f :: * -> *} {f :: * -> *} {a} {b}.
(Functor f, Functor f) =>
(a -> b) -> f (f a) -> f (f b)
fmap2 a -> b
f s -> m a
final)
where
initial :: m (Step s b)
initial = (a -> b) -> m (Step s a) -> m (Step s b)
forall {f :: * -> *} {f :: * -> *} {a} {b}.
(Functor f, Functor f) =>
(a -> b) -> f (f a) -> f (f b)
fmap2 a -> b
f m (Step s a)
initial1
step :: s -> a -> m (Step s b)
step s
s a
b = (a -> b) -> m (Step s a) -> m (Step s b)
forall {f :: * -> *} {f :: * -> *} {a} {b}.
(Functor f, Functor f) =>
(a -> b) -> f (f a) -> f (f b)
fmap2 a -> b
f (s -> a -> m (Step s a)
step1 s
s a
b)
fmap2 :: (a -> b) -> f (f a) -> f (f b)
fmap2 a -> b
g = (f a -> f b) -> f (f a) -> f (f b)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> f a -> f b
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
g)
{-# INLINE mkScanl1 #-}
mkScanl1 :: Monad m => (a -> a -> a) -> Scanl m a (Maybe a)
mkScanl1 :: forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Scanl m a (Maybe a)
mkScanl1 a -> a -> a
step = (Maybe' a -> Maybe a)
-> Scanl m a (Maybe' a) -> Scanl m a (Maybe a)
forall a b. (a -> b) -> Scanl m a a -> Scanl m a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe' a -> Maybe a
forall a. Maybe' a -> Maybe a
toMaybe (Scanl m a (Maybe' a) -> Scanl m a (Maybe a))
-> Scanl m a (Maybe' a) -> Scanl m a (Maybe a)
forall a b. (a -> b) -> a -> b
$ (Maybe' a -> a -> Maybe' a) -> Maybe' a -> Scanl m a (Maybe' a)
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Scanl m a b
mkScanl Maybe' a -> a -> Maybe' a
step1 Maybe' a
forall a. Maybe' a
Nothing'
where
step1 :: Maybe' a -> a -> Maybe' a
step1 Maybe' a
Nothing' a
a = a -> Maybe' a
forall a. a -> Maybe' a
Just' a
a
step1 (Just' a
x) a
a = a -> Maybe' a
forall a. a -> Maybe' a
Just' (a -> Maybe' a) -> a -> Maybe' a
forall a b. (a -> b) -> a -> b
$ a -> a -> a
step a
x a
a
{-# INLINE mkScanl1M #-}
mkScanl1M :: Monad m => (a -> a -> m a) -> Scanl m a (Maybe a)
mkScanl1M :: forall (m :: * -> *) a.
Monad m =>
(a -> a -> m a) -> Scanl m a (Maybe a)
mkScanl1M a -> a -> m a
step = (Maybe' a -> Maybe a)
-> Scanl m a (Maybe' a) -> Scanl m a (Maybe a)
forall a b. (a -> b) -> Scanl m a a -> Scanl m a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe' a -> Maybe a
forall a. Maybe' a -> Maybe a
toMaybe (Scanl m a (Maybe' a) -> Scanl m a (Maybe a))
-> Scanl m a (Maybe' a) -> Scanl m a (Maybe a)
forall a b. (a -> b) -> a -> b
$ (Maybe' a -> a -> m (Maybe' a))
-> m (Maybe' a) -> Scanl m a (Maybe' a)
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> m b) -> m b -> Scanl m a b
mkScanlM Maybe' a -> a -> m (Maybe' a)
step1 (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')
where
step1 :: Maybe' a -> a -> m (Maybe' a)
step1 Maybe' a
Nothing' a
a = 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 -> m (Maybe' a)
forall a b. (a -> b) -> a -> b
$ a -> Maybe' a
forall a. a -> Maybe' a
Just' a
a
step1 (Just' a
x) a
a = a -> Maybe' a
forall a. a -> Maybe' a
Just' (a -> Maybe' a) -> m a -> m (Maybe' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> a -> m a
step a
x a
a
{-# INLINE mkScanr #-}
mkScanr :: Monad m => (a -> b -> b) -> b -> Scanl m a b
mkScanr :: forall (m :: * -> *) a b.
Monad m =>
(a -> b -> b) -> b -> Scanl m a b
mkScanr a -> b -> b
f b
z = ((b -> b) -> b) -> Scanl m a (b -> b) -> Scanl m a b
forall a b. (a -> b) -> Scanl m a a -> Scanl m a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((b -> b) -> b -> b
forall a b. (a -> b) -> a -> b
$ b
z) (Scanl m a (b -> b) -> Scanl m a b)
-> Scanl m a (b -> b) -> Scanl m a b
forall a b. (a -> b) -> a -> b
$ ((b -> b) -> a -> b -> b) -> (b -> b) -> Scanl m a (b -> b)
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Scanl m a b
mkScanl (\b -> b
g a
x -> b -> b
g (b -> b) -> (b -> b) -> b -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b -> b
f a
x) b -> b
forall a. a -> a
id
{-# INLINE mkScanrM #-}
mkScanrM :: Monad m => (a -> b -> m b) -> m b -> Scanl m a b
mkScanrM :: forall (m :: * -> *) a b.
Monad m =>
(a -> b -> m b) -> m b -> Scanl m a b
mkScanrM a -> b -> m b
g m b
z =
((b -> m b) -> m b) -> Scanl m a (b -> m b) -> Scanl m a b
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> Scanl m a b -> Scanl m a c
rmapM (m b
z m b -> (b -> m b) -> m b
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=) (Scanl m a (b -> m b) -> Scanl m a b)
-> Scanl m a (b -> m b) -> Scanl m a b
forall a b. (a -> b) -> a -> b
$ ((b -> m b) -> a -> m (b -> m b))
-> m (b -> m b) -> Scanl m a (b -> m b)
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> m b) -> m b -> Scanl m a b
mkScanlM (\b -> m b
f a
x -> (b -> m b) -> m (b -> m b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ((b -> m b) -> m (b -> m b)) -> (b -> m b) -> m (b -> m b)
forall a b. (a -> b) -> a -> b
$ a -> b -> m b
g a
x (b -> m b) -> (b -> m b) -> b -> m b
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> b -> m b
f) ((b -> m b) -> m (b -> m b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return)
{-# INLINE mkScant #-}
mkScant :: Monad m => (s -> a -> Step s b) -> Step s b -> (s -> b) -> Scanl m a b
mkScant :: forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> Step s b) -> Step s b -> (s -> b) -> Scanl m a b
mkScant s -> a -> Step s b
step Step s b
initial s -> b
extract =
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> 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
(\s
s a
a -> 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 -> a -> Step s b
step s
s a
a)
(Step s b -> m (Step s b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Step s b
initial)
(b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> m b) -> (s -> b) -> s -> m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> b
extract)
(b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> m b) -> (s -> b) -> s -> m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> b
extract)
{-# INLINE mkScantM #-}
mkScantM :: (s -> a -> m (Step s b)) -> m (Step s b) -> (s -> m b) -> Scanl m a b
mkScantM :: forall s a (m :: * -> *) b.
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> Scanl m a b
mkScantM s -> a -> m (Step s b)
step m (Step s b)
initial s -> m b
extract = (s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> 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 s -> a -> m (Step s b)
step m (Step s b)
initial s -> m b
extract s -> m b
extract
fromRefold :: Refold m c a b -> c -> Scanl m a b
fromRefold :: forall (m :: * -> *) c a b. Refold m c a b -> c -> Scanl m a b
fromRefold (Refold s -> a -> m (Step s b)
step c -> m (Step s b)
inject s -> m b
extract) c
c =
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> 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 s -> a -> m (Step s b)
step (c -> m (Step s b)
inject c
c) s -> m b
extract s -> m b
extract
{-# INLINE drain #-}
drain :: Monad m => Scanl m a ()
drain :: forall (m :: * -> *) a. Monad m => Scanl m a ()
drain = (() -> a -> ()) -> () -> Scanl m a ()
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Scanl m a b
mkScanl (\()
_ a
_ -> ()) ()
{-# INLINE latest #-}
latest :: Monad m => Scanl m a (Maybe a)
latest :: forall (m :: * -> *) a. Monad m => Scanl m a (Maybe a)
latest = (a -> a -> a) -> Scanl m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Scanl m a (Maybe a)
mkScanl1 (\a
_ a
x -> a
x)
functionM :: Monad m => (a -> m (Maybe b)) -> Scanl m a (Maybe b)
functionM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m (Maybe b)) -> Scanl m a (Maybe b)
functionM a -> m (Maybe b)
f = (Maybe b -> a -> m (Step (Maybe b) (Maybe b)))
-> m (Step (Maybe b) (Maybe b))
-> (Maybe b -> m (Maybe b))
-> (Maybe b -> m (Maybe b))
-> Scanl m a (Maybe 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 Maybe b -> a -> m (Step (Maybe b) (Maybe b))
forall {p} {b}. p -> a -> m (Step (Maybe b) b)
step m (Step (Maybe b) (Maybe b))
forall {a} {b}. m (Step (Maybe a) b)
initial Maybe b -> m (Maybe b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe b -> m (Maybe b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
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 b) b)
step p
_ a
x = a -> m (Maybe b)
f a
x m (Maybe b)
-> (Maybe b -> Step (Maybe b) b) -> m (Step (Maybe b) b)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Maybe b -> Step (Maybe b) b
forall s b. s -> Step s b
Partial
{-# INLINE toList #-}
toList :: Monad m => Scanl m a [a]
toList :: forall (m :: * -> *) a. Monad m => Scanl m a [a]
toList = (a -> [a] -> [a]) -> [a] -> Scanl m a [a]
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> b) -> b -> Scanl m a b
mkScanr (:) []
{-# INLINE toStreamKRev #-}
toStreamKRev :: Monad m => Scanl m a (K.StreamK n a)
toStreamKRev :: forall (m :: * -> *) a (n :: * -> *).
Monad m =>
Scanl m a (StreamK n a)
toStreamKRev = (StreamK n a -> a -> StreamK n a)
-> StreamK n a -> Scanl m a (StreamK n a)
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Scanl m a b
mkScanl ((a -> StreamK n a -> StreamK n a)
-> StreamK n a -> a -> StreamK n a
forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> StreamK n a -> StreamK n a
forall a (m :: * -> *). a -> StreamK m a -> StreamK m a
K.cons) StreamK n a
forall (m :: * -> *) a. StreamK m a
K.nil
{-# INLINE toStreamK #-}
toStreamK :: Monad m => Scanl m a (K.StreamK n a)
toStreamK :: forall (m :: * -> *) a (n :: * -> *).
Monad m =>
Scanl m a (StreamK n a)
toStreamK = (a -> StreamK n a -> StreamK n a)
-> StreamK n a -> Scanl m a (StreamK n a)
forall (m :: * -> *) a b.
Monad m =>
(a -> b -> b) -> b -> Scanl m a b
mkScanr a -> StreamK n a -> StreamK n a
forall a (m :: * -> *). a -> StreamK m a -> StreamK m a
K.cons StreamK n a
forall (m :: * -> *) a. StreamK m a
K.nil
{-# INLINE genericLength #-}
genericLength :: (Monad m, Num b) => Scanl m a b
genericLength :: forall (m :: * -> *) b a. (Monad m, Num b) => Scanl m a b
genericLength = (b -> a -> b) -> b -> Scanl m a b
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Scanl m a b
mkScanl (\b
n a
_ -> b
n b -> b -> b
forall a. Num a => a -> a -> a
+ b
1) b
0
{-# INLINE length #-}
length :: Monad m => Scanl m a Int
length :: forall (m :: * -> *) a. Monad m => Scanl m a Int
length = Scanl m a Int
forall (m :: * -> *) b a. (Monad m, Num b) => Scanl m a b
genericLength
{-# INLINE maxBy #-}
maxBy :: (a -> a -> Ordering) -> a -> a -> a
maxBy :: forall a. (a -> a -> Ordering) -> a -> a -> a
maxBy a -> a -> Ordering
cmp a
x a
y =
case a -> a -> Ordering
cmp a
x a
y of
Ordering
GT -> a
x
Ordering
_ -> a
y
{-# INLINE maximumBy #-}
maximumBy :: Monad m => (a -> a -> Ordering) -> Scanl m a (Maybe a)
maximumBy :: forall (m :: * -> *) a.
Monad m =>
(a -> a -> Ordering) -> Scanl m a (Maybe a)
maximumBy a -> a -> Ordering
cmp = (a -> a -> a) -> Scanl m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Scanl m a (Maybe a)
mkScanl1 ((a -> a -> Ordering) -> a -> a -> a
forall a. (a -> a -> Ordering) -> a -> a -> a
maxBy a -> a -> Ordering
cmp)
{-# INLINE maximum #-}
maximum :: (Monad m, Ord a) => Scanl m a (Maybe a)
maximum :: forall (m :: * -> *) a. (Monad m, Ord a) => Scanl m a (Maybe a)
maximum = (a -> a -> a) -> Scanl m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Scanl m a (Maybe a)
mkScanl1 a -> a -> a
forall a. Ord a => a -> a -> a
max
{-# INLINE minBy #-}
minBy :: (a -> a -> Ordering) -> a -> a -> a
minBy :: forall a. (a -> a -> Ordering) -> a -> a -> a
minBy a -> a -> Ordering
cmp a
x a
y =
case a -> a -> Ordering
cmp a
x a
y of
Ordering
GT -> a
y
Ordering
_ -> a
x
{-# INLINE minimumBy #-}
minimumBy :: Monad m => (a -> a -> Ordering) -> Scanl m a (Maybe a)
minimumBy :: forall (m :: * -> *) a.
Monad m =>
(a -> a -> Ordering) -> Scanl m a (Maybe a)
minimumBy a -> a -> Ordering
cmp = (a -> a -> a) -> Scanl m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Scanl m a (Maybe a)
mkScanl1 ((a -> a -> Ordering) -> a -> a -> a
forall a. (a -> a -> Ordering) -> a -> a -> a
minBy a -> a -> Ordering
cmp)
{-# INLINE minimum #-}
minimum :: (Monad m, Ord a) => Scanl m a (Maybe a)
minimum :: forall (m :: * -> *) a. (Monad m, Ord a) => Scanl m a (Maybe a)
minimum = (a -> a -> a) -> Scanl m a (Maybe a)
forall (m :: * -> *) a.
Monad m =>
(a -> a -> a) -> Scanl m a (Maybe a)
mkScanl1 a -> a -> a
forall a. Ord a => a -> a -> a
min
extractRange :: Range a -> Maybe (a, a)
Range a
RangeNone = Maybe (a, a)
forall a. Maybe a
Nothing
extractRange (Range a
mn a
mx) = (a, a) -> Maybe (a, a)
forall a. a -> Maybe a
Just (a
mn, a
mx)
data Range a = RangeNone | Range !a !a
{-# INLINE rangeBy #-}
rangeBy :: Monad m => (a -> a -> Ordering) -> Scanl m a (Maybe (a, a))
rangeBy :: forall (m :: * -> *) a.
Monad m =>
(a -> a -> Ordering) -> Scanl m a (Maybe (a, a))
rangeBy a -> a -> Ordering
cmp = (Range a -> Maybe (a, a))
-> Scanl m a (Range a) -> Scanl m a (Maybe (a, a))
forall a b. (a -> b) -> Scanl m a a -> Scanl m a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Range a -> Maybe (a, a)
forall a. Range a -> Maybe (a, a)
extractRange (Scanl m a (Range a) -> Scanl m a (Maybe (a, a)))
-> Scanl m a (Range a) -> Scanl m a (Maybe (a, a))
forall a b. (a -> b) -> a -> b
$ (Range a -> a -> Range a) -> Range a -> Scanl m a (Range a)
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Scanl m a b
mkScanl Range a -> a -> Range a
step Range a
forall a. Range a
RangeNone
where
step :: Range a -> a -> Range a
step Range a
RangeNone a
x = a -> a -> Range a
forall a. a -> a -> Range a
Range a
x a
x
step (Range a
mn a
mx) a
x = a -> a -> Range a
forall a. a -> a -> Range a
Range ((a -> a -> Ordering) -> a -> a -> a
forall a. (a -> a -> Ordering) -> a -> a -> a
minBy a -> a -> Ordering
cmp a
mn a
x) ((a -> a -> Ordering) -> a -> a -> a
forall a. (a -> a -> Ordering) -> a -> a -> a
maxBy a -> a -> Ordering
cmp a
mx a
x)
{-# INLINE range #-}
range :: (Monad m, Ord a) => Scanl m a (Maybe (a, a))
range :: forall (m :: * -> *) a.
(Monad m, Ord a) =>
Scanl m a (Maybe (a, a))
range = (Range a -> Maybe (a, a))
-> Scanl m a (Range a) -> Scanl m a (Maybe (a, a))
forall a b. (a -> b) -> Scanl m a a -> Scanl m a b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Range a -> Maybe (a, a)
forall a. Range a -> Maybe (a, a)
extractRange (Scanl m a (Range a) -> Scanl m a (Maybe (a, a)))
-> Scanl m a (Range a) -> Scanl m a (Maybe (a, a))
forall a b. (a -> b) -> a -> b
$ (Range a -> a -> Range a) -> Range a -> Scanl m a (Range a)
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Scanl m a b
mkScanl Range a -> a -> Range a
forall {a}. Ord a => Range a -> a -> Range a
step Range a
forall a. Range a
RangeNone
where
step :: Range a -> a -> Range a
step Range a
RangeNone a
x = a -> a -> Range a
forall a. a -> a -> Range a
Range a
x a
x
step (Range a
mn a
mx) a
x = a -> a -> Range a
forall a. a -> a -> Range a
Range (a -> a -> a
forall a. Ord a => a -> a -> a
min a
mn a
x) (a -> a -> a
forall a. Ord a => a -> a -> a
max a
mx a
x)
{-# INLINE const #-}
const :: Applicative m => b -> Scanl m a b
const :: forall (m :: * -> *) b a. Applicative m => b -> Scanl m a b
const b
b = (b -> a -> m (Step b b))
-> m (Step b b) -> (b -> m 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 (\b
s a
_ -> Step b b -> m (Step b b)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Step b b -> m (Step b b)) -> Step b b -> m (Step b b)
forall a b. (a -> b) -> a -> b
$ b -> Step b b
forall s b. s -> Step s b
Partial b
s) (Step b b -> m (Step b b)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Step b b -> m (Step b b)) -> Step b b -> m (Step b b)
forall a b. (a -> b) -> a -> b
$ b -> Step b b
forall s b. s -> Step s b
Partial b
b) b -> m b
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure b -> m b
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
{-# INLINE constM #-}
constM :: Applicative m => m b -> Scanl m a b
constM :: forall (m :: * -> *) b a. Applicative m => m b -> Scanl m a b
constM m b
b = (b -> a -> m (Step b b))
-> m (Step b b) -> (b -> m 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 (\b
s a
_ -> Step b b -> m (Step b b)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Step b b -> m (Step b b)) -> Step b b -> m (Step b b)
forall a b. (a -> b) -> a -> b
$ b -> Step b b
forall s b. s -> Step s b
Partial b
s) (b -> Step b b
forall s b. s -> Step s b
Partial (b -> Step b b) -> m b -> m (Step b b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m b
b) b -> m b
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure b -> m b
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
{-# INLINE teeWith #-}
teeWith :: Monad m =>
(b -> c -> d) -> Scanl m a b -> Scanl m a c -> Scanl m a d
teeWith :: forall (m :: * -> *) b c d a.
Monad m =>
(b -> c -> d) -> Scanl m a b -> Scanl m a c -> Scanl m a d
teeWith b -> c -> d
f
(Scanl s -> a -> m (Step s b)
stepL m (Step s b)
initialL s -> m b
extractL s -> m b
finalL)
(Scanl s -> a -> m (Step s c)
stepR m (Step s c)
initialR s -> m c
extractR s -> m c
finalR) =
(Tuple' s s -> a -> m (Step (Tuple' s s) d))
-> m (Step (Tuple' s s) d)
-> (Tuple' s s -> m d)
-> (Tuple' s s -> m d)
-> Scanl m a d
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' s s -> a -> m (Step (Tuple' s s) d)
step m (Step (Tuple' s s) d)
initial Tuple' s s -> m d
extract Tuple' s s -> m d
final
where
{-# INLINE runBoth #-}
runBoth :: m (Step s b) -> m (Step s c) -> m (Step (Tuple' s s) d)
runBoth m (Step s b)
actionL m (Step s c)
actionR = do
Step s b
resL <- m (Step s b)
actionL
Step s c
resR <- m (Step s c)
actionR
case Step s b
resL of
Partial s
sl -> do
case Step s c
resR of
Partial s
sr -> Step (Tuple' s s) d -> m (Step (Tuple' s s) d)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Tuple' s s) d -> m (Step (Tuple' s s) d))
-> Step (Tuple' s s) d -> m (Step (Tuple' s s) d)
forall a b. (a -> b) -> a -> b
$ Tuple' s s -> Step (Tuple' s s) d
forall s b. s -> Step s b
Partial (Tuple' s s -> Step (Tuple' s s) d)
-> Tuple' s s -> Step (Tuple' s s) d
forall a b. (a -> b) -> a -> b
$ s -> s -> Tuple' s s
forall a b. a -> b -> Tuple' a b
Tuple' s
sl s
sr
Done c
br -> d -> Step (Tuple' s s) d
forall s b. b -> Step s b
Done (d -> Step (Tuple' s s) d) -> (b -> d) -> b -> Step (Tuple' s s) d
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> c -> d
`f` c
br) (b -> Step (Tuple' s s) d) -> m b -> m (Step (Tuple' s s) d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
finalL s
sl
Done b
bl -> do
d -> Step (Tuple' s s) d
forall s b. b -> Step s b
Done (d -> Step (Tuple' s s) d) -> (c -> d) -> c -> Step (Tuple' s s) d
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> c -> d
f b
bl (c -> Step (Tuple' s s) d) -> m c -> m (Step (Tuple' s s) d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
case Step s c
resR of
Partial s
sr -> s -> m c
finalR s
sr
Done c
br -> c -> m c
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return c
br
initial :: m (Step (Tuple' s s) d)
initial = m (Step s b) -> m (Step s c) -> m (Step (Tuple' s s) d)
runBoth m (Step s b)
initialL m (Step s c)
initialR
step :: Tuple' s s -> a -> m (Step (Tuple' s s) d)
step (Tuple' s
sL s
sR) a
a = m (Step s b) -> m (Step s c) -> m (Step (Tuple' s s) d)
runBoth (s -> a -> m (Step s b)
stepL s
sL a
a) (s -> a -> m (Step s c)
stepR s
sR a
a)
extract :: Tuple' s s -> m d
extract (Tuple' s
sL s
sR) = b -> c -> d
f (b -> c -> d) -> m b -> m (c -> d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
extractL s
sL m (c -> d) -> m c -> m d
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> s -> m c
extractR s
sR
final :: Tuple' s s -> m d
final (Tuple' s
sL s
sR) = b -> c -> d
f (b -> c -> d) -> m b -> m (c -> d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
finalL s
sL m (c -> d) -> m c -> m d
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> s -> m c
finalR s
sR
instance Monad m => Applicative (Scanl m a) where
{-# INLINE pure #-}
pure :: forall a. a -> Scanl m a a
pure = a -> Scanl m a a
forall (m :: * -> *) b a. Applicative m => b -> Scanl m a b
const
<*> :: forall a b. Scanl m a (a -> b) -> Scanl m a a -> Scanl m a b
(<*>) = ((a -> b) -> a -> b)
-> Scanl m a (a -> b) -> Scanl m a a -> Scanl m a b
forall (m :: * -> *) b c d a.
Monad m =>
(b -> c -> d) -> Scanl m a b -> Scanl m a c -> Scanl m a d
teeWith (a -> b) -> a -> b
forall a. a -> a
id
{-# INLINE lmap #-}
lmap :: (a -> b) -> Scanl m b r -> Scanl m a r
lmap :: forall a b (m :: * -> *) r. (a -> b) -> Scanl m b r -> Scanl m a r
lmap a -> b
f (Scanl s -> b -> m (Step s r)
step m (Step s r)
begin s -> m r
done s -> m r
final) = (s -> a -> m (Step s r))
-> m (Step s r) -> (s -> m r) -> (s -> m r) -> Scanl m a r
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 s -> a -> m (Step s r)
step' m (Step s r)
begin s -> m r
done s -> m r
final
where
step' :: s -> a -> m (Step s r)
step' s
x a
a = s -> b -> m (Step s r)
step s
x (a -> b
f a
a)
{-# INLINE lmapM #-}
lmapM :: Monad m => (a -> m b) -> Scanl m b r -> Scanl m a r
lmapM :: forall (m :: * -> *) a b r.
Monad m =>
(a -> m b) -> Scanl m b r -> Scanl m a r
lmapM a -> m b
f (Scanl s -> b -> m (Step s r)
step m (Step s r)
begin s -> m r
done s -> m r
final) = (s -> a -> m (Step s r))
-> m (Step s r) -> (s -> m r) -> (s -> m r) -> Scanl m a r
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 s -> a -> m (Step s r)
step' m (Step s r)
begin s -> m r
done s -> m r
final
where
step' :: s -> a -> m (Step s r)
step' s
x a
a = a -> m b
f a
a m b -> (b -> m (Step s r)) -> m (Step s r)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= s -> b -> m (Step s r)
step s
x
{-# INLINE postscanl #-}
postscanl :: Monad m => Scanl m a b -> Scanl m b c -> Scanl m a c
postscanl :: forall (m :: * -> *) a b c.
Monad m =>
Scanl m a b -> Scanl m b c -> Scanl m a c
postscanl
(Scanl s -> a -> m (Step s b)
stepL m (Step s b)
initialL s -> m b
extractL s -> m b
finalL)
(Scanl s -> b -> m (Step s c)
stepR m (Step s c)
initialR s -> m c
extractR s -> m c
finalR) =
((s, s) -> a -> m (Step (s, s) c))
-> m (Step (s, s) c)
-> ((s, s) -> m c)
-> ((s, s) -> m c)
-> Scanl m a c
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 (s, s) -> a -> m (Step (s, s) c)
step m (Step (s, s) c)
initial (s, s) -> m c
forall {a}. (a, s) -> m c
extract (s, s) -> m c
final
where
{-# INLINE runStep #-}
runStep :: m (Step s b) -> s -> m (Step (s, s) c)
runStep m (Step s b)
actionL s
sR = do
Step s b
rL <- m (Step s b)
actionL
case Step s b
rL of
Done b
bL -> do
Step s c
rR <- s -> b -> m (Step s c)
stepR s
sR b
bL
case Step s c
rR of
Partial s
sR1 -> c -> Step (s, s) c
forall s b. b -> Step s b
Done (c -> Step (s, s) c) -> m c -> m (Step (s, s) c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m c
finalR s
sR1
Done c
bR -> Step (s, s) c -> m (Step (s, s) c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (s, s) c -> m (Step (s, s) c))
-> Step (s, s) c -> m (Step (s, s) c)
forall a b. (a -> b) -> a -> b
$ c -> Step (s, s) c
forall s b. b -> Step s b
Done c
bR
Partial s
sL -> do
!b
b <- s -> m b
extractL s
sL
Step s c
rR <- s -> b -> m (Step s c)
stepR s
sR b
b
case Step s c
rR of
Partial s
sR1 -> Step (s, s) c -> m (Step (s, s) c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (s, s) c -> m (Step (s, s) c))
-> Step (s, s) c -> m (Step (s, s) c)
forall a b. (a -> b) -> a -> b
$ (s, s) -> Step (s, s) c
forall s b. s -> Step s b
Partial (s
sL, s
sR1)
Done c
bR -> s -> m b
finalL s
sL m b -> m (Step (s, s) c) -> m (Step (s, s) c)
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Step (s, s) c -> m (Step (s, s) c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (c -> Step (s, s) c
forall s b. b -> Step s b
Done c
bR)
initial :: m (Step (s, s) c)
initial = do
Step s c
rR <- m (Step s c)
initialR
case Step s c
rR of
Partial s
sR -> do
Step s b
rL <- m (Step s b)
initialL
case Step s b
rL of
Done b
_ -> c -> Step (s, s) c
forall s b. b -> Step s b
Done (c -> Step (s, s) c) -> m c -> m (Step (s, s) c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m c
finalR s
sR
Partial s
sL -> Step (s, s) c -> m (Step (s, s) c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (s, s) c -> m (Step (s, s) c))
-> Step (s, s) c -> m (Step (s, s) c)
forall a b. (a -> b) -> a -> b
$ (s, s) -> Step (s, s) c
forall s b. s -> Step s b
Partial (s
sL, s
sR)
Done c
b -> Step (s, s) c -> m (Step (s, s) c)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (s, s) c -> m (Step (s, s) c))
-> Step (s, s) c -> m (Step (s, s) c)
forall a b. (a -> b) -> a -> b
$ c -> Step (s, s) c
forall s b. b -> Step s b
Done c
b
step :: (s, s) -> a -> m (Step (s, s) c)
step (s
sL, s
sR) a
x = m (Step s b) -> s -> m (Step (s, s) c)
runStep (s -> a -> m (Step s b)
stepL s
sL a
x) s
sR
extract :: (a, s) -> m c
extract = s -> m c
extractR (s -> m c) -> ((a, s) -> s) -> (a, s) -> m c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, s) -> s
forall a b. (a, b) -> b
snd
final :: (s, s) -> m c
final (s
sL, s
sR) = 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
{-# INLINE_NORMAL catMaybes #-}
catMaybes :: Monad m => Scanl m a b -> Scanl m (Maybe a) b
catMaybes :: forall (m :: * -> *) a b.
Monad m =>
Scanl m a b -> Scanl m (Maybe a) b
catMaybes (Scanl s -> a -> m (Step s b)
step m (Step s b)
initial s -> m b
extract s -> m b
final) =
(s -> Maybe a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> m b) -> Scanl m (Maybe 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 s -> Maybe a -> m (Step s b)
step1 m (Step s b)
initial s -> m b
extract s -> m b
final
where
step1 :: s -> Maybe a -> m (Step s b)
step1 s
s Maybe a
a =
case Maybe a
a of
Maybe a
Nothing -> 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
Just a
x -> s -> a -> m (Step s b)
step s
s a
x
{-# INLINE postscanlMaybe #-}
postscanlMaybe :: Monad m => Scanl m a (Maybe b) -> Scanl m b c -> Scanl m a c
postscanlMaybe :: forall (m :: * -> *) a b c.
Monad m =>
Scanl m a (Maybe b) -> Scanl m b c -> Scanl m a c
postscanlMaybe Scanl m a (Maybe b)
f1 Scanl m b c
f2 = Scanl m a (Maybe b) -> Scanl m (Maybe b) c -> Scanl m a c
forall (m :: * -> *) a b c.
Monad m =>
Scanl m a b -> Scanl m b c -> Scanl m a c
postscanl Scanl m a (Maybe b)
f1 (Scanl m b c -> Scanl m (Maybe b) c
forall (m :: * -> *) a b.
Monad m =>
Scanl m a b -> Scanl m (Maybe a) b
catMaybes Scanl m b c
f2)
{-# INLINE filtering #-}
filtering :: Monad m => (a -> Bool) -> Scanl m a (Maybe a)
filtering :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> Scanl m a (Maybe a)
filtering a -> Bool
f = (Maybe a -> a -> Maybe a) -> Maybe a -> Scanl m a (Maybe a)
forall (m :: * -> *) b a.
Monad m =>
(b -> a -> b) -> b -> Scanl m a b
mkScanl Maybe a -> a -> Maybe a
forall {p}. p -> a -> Maybe a
step Maybe a
forall a. Maybe a
Nothing
where
step :: p -> a -> Maybe a
step p
_ 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 filter #-}
filter :: Monad m => (a -> Bool) -> Scanl m a r -> Scanl m a r
filter :: forall (m :: * -> *) a r.
Monad m =>
(a -> Bool) -> Scanl m a r -> Scanl m a r
filter a -> Bool
f (Scanl s -> a -> m (Step s r)
step m (Step s r)
begin s -> m r
extract s -> m r
final) = (s -> a -> m (Step s r))
-> m (Step s r) -> (s -> m r) -> (s -> m r) -> Scanl m a r
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 s -> a -> m (Step s r)
step' m (Step s r)
begin s -> m r
extract s -> m r
final
where
step' :: s -> a -> m (Step s r)
step' s
x a
a = if a -> Bool
f a
a then s -> a -> m (Step s r)
step s
x a
a else Step s r -> m (Step s r)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step s r -> m (Step s r)) -> Step s r -> m (Step s r)
forall a b. (a -> b) -> a -> b
$ s -> Step s r
forall s b. s -> Step s b
Partial s
x
{-# INLINE filterM #-}
filterM :: Monad m => (a -> m Bool) -> Scanl m a r -> Scanl m a r
filterM :: forall (m :: * -> *) a r.
Monad m =>
(a -> m Bool) -> Scanl m a r -> Scanl m a r
filterM a -> m Bool
f (Scanl s -> a -> m (Step s r)
step m (Step s r)
begin s -> m r
extract s -> m r
final) = (s -> a -> m (Step s r))
-> m (Step s r) -> (s -> m r) -> (s -> m r) -> Scanl m a r
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 s -> a -> m (Step s r)
step' m (Step s r)
begin s -> m r
extract s -> m r
final
where
step' :: s -> a -> m (Step s r)
step' s
x a
a = do
Bool
use <- a -> m Bool
f a
a
if Bool
use then s -> a -> m (Step s r)
step s
x a
a else Step s r -> m (Step s r)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step s r -> m (Step s r)) -> Step s r -> m (Step s r)
forall a b. (a -> b) -> a -> b
$ s -> Step s r
forall s b. s -> Step s b
Partial s
x
{-# INLINE catLefts #-}
catLefts :: (Monad m) => Scanl m a c -> Scanl m (Either a b) c
catLefts :: forall (m :: * -> *) a c b.
Monad m =>
Scanl m a c -> Scanl m (Either a b) c
catLefts = (Either a b -> Bool)
-> Scanl m (Either a b) c -> Scanl m (Either a b) c
forall (m :: * -> *) a r.
Monad m =>
(a -> Bool) -> Scanl m a r -> Scanl m a r
filter Either a b -> Bool
forall a b. Either a b -> Bool
isLeft (Scanl m (Either a b) c -> Scanl m (Either a b) c)
-> (Scanl m a c -> Scanl m (Either a b) c)
-> Scanl m a c
-> Scanl m (Either a b) c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either a b -> a) -> Scanl m a c -> Scanl m (Either a b) c
forall a b (m :: * -> *) r. (a -> b) -> Scanl m b r -> Scanl m a r
lmap (a -> Either a b -> a
forall a b. a -> Either a b -> a
fromLeft a
forall a. HasCallStack => a
undefined)
{-# INLINE catRights #-}
catRights :: (Monad m) => Scanl m b c -> Scanl m (Either a b) c
catRights :: forall (m :: * -> *) b c a.
Monad m =>
Scanl m b c -> Scanl m (Either a b) c
catRights = (Either a b -> Bool)
-> Scanl m (Either a b) c -> Scanl m (Either a b) c
forall (m :: * -> *) a r.
Monad m =>
(a -> Bool) -> Scanl m a r -> Scanl m a r
filter Either a b -> Bool
forall a b. Either a b -> Bool
isRight (Scanl m (Either a b) c -> Scanl m (Either a b) c)
-> (Scanl m b c -> Scanl m (Either a b) c)
-> Scanl m b c
-> Scanl m (Either a b) c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either a b -> b) -> Scanl m b c -> Scanl m (Either a b) c
forall a b (m :: * -> *) r. (a -> b) -> Scanl m b r -> Scanl m a r
lmap (b -> Either a b -> b
forall b a. b -> Either a b -> b
fromRight b
forall a. HasCallStack => a
undefined)
{-# INLINE catEithers #-}
catEithers :: Scanl m a b -> Scanl m (Either a a) b
catEithers :: forall (m :: * -> *) a b. Scanl m a b -> Scanl m (Either a a) b
catEithers = (Either a a -> a) -> Scanl m a b -> Scanl m (Either a a) b
forall a b (m :: * -> *) r. (a -> b) -> Scanl m b r -> Scanl m a r
lmap ((a -> a) -> (a -> a) -> Either a a -> a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either a -> a
forall a. a -> a
id a -> a
forall a. a -> a
id)
{-# ANN type Tuple'Fused Fuse #-}
data Tuple'Fused a b = Tuple'Fused !a !b deriving Int -> Tuple'Fused a b -> ShowS
[Tuple'Fused a b] -> ShowS
Tuple'Fused a b -> String
(Int -> Tuple'Fused a b -> ShowS)
-> (Tuple'Fused a b -> String)
-> ([Tuple'Fused a b] -> ShowS)
-> Show (Tuple'Fused a b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b. (Show a, Show b) => Int -> Tuple'Fused a b -> ShowS
forall a b. (Show a, Show b) => [Tuple'Fused a b] -> ShowS
forall a b. (Show a, Show b) => Tuple'Fused a b -> String
$cshowsPrec :: forall a b. (Show a, Show b) => Int -> Tuple'Fused a b -> ShowS
showsPrec :: Int -> Tuple'Fused a b -> ShowS
$cshow :: forall a b. (Show a, Show b) => Tuple'Fused a b -> String
show :: Tuple'Fused a b -> String
$cshowList :: forall a b. (Show a, Show b) => [Tuple'Fused a b] -> ShowS
showList :: [Tuple'Fused a b] -> ShowS
Show
{-# INLINE taking #-}
taking :: Monad m => Int -> Scanl m a (Maybe a)
taking :: forall (m :: * -> *) a. Monad m => Int -> Scanl m a (Maybe a)
taking Int
n = (Tuple'Fused Int (Maybe a)
-> a -> Step (Tuple'Fused Int (Maybe a)) (Maybe a))
-> Step (Tuple'Fused Int (Maybe a)) (Maybe a)
-> (Tuple'Fused Int (Maybe a) -> Maybe a)
-> Scanl m a (Maybe a)
forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> Step s b) -> Step s b -> (s -> b) -> Scanl m a b
mkScant Tuple'Fused Int (Maybe a)
-> a -> Step (Tuple'Fused Int (Maybe a)) (Maybe a)
forall {a} {b} {a}.
(Ord a, Num a) =>
Tuple'Fused a b -> a -> Step (Tuple'Fused a (Maybe a)) (Maybe a)
step Step (Tuple'Fused Int (Maybe a)) (Maybe a)
forall {a} {a}. Step (Tuple'Fused Int (Maybe a)) (Maybe a)
initial Tuple'Fused Int (Maybe a) -> Maybe a
forall {a} {b}. Tuple'Fused a b -> b
extract
where
initial :: Step (Tuple'Fused Int (Maybe a)) (Maybe a)
initial =
if Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0
then Maybe a -> Step (Tuple'Fused Int (Maybe a)) (Maybe a)
forall s b. b -> Step s b
Done Maybe a
forall a. Maybe a
Nothing
else Tuple'Fused Int (Maybe a)
-> Step (Tuple'Fused Int (Maybe a)) (Maybe a)
forall s b. s -> Step s b
Partial (Int -> Maybe a -> Tuple'Fused Int (Maybe a)
forall a b. a -> b -> Tuple'Fused a b
Tuple'Fused Int
n Maybe a
forall a. Maybe a
Nothing)
step :: Tuple'Fused a b -> a -> Step (Tuple'Fused a (Maybe a)) (Maybe a)
step (Tuple'Fused a
i b
_) a
a =
if a
i a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
1
then Tuple'Fused a (Maybe a) -> Step (Tuple'Fused a (Maybe a)) (Maybe a)
forall s b. s -> Step s b
Partial (a -> Maybe a -> Tuple'Fused a (Maybe a)
forall a b. a -> b -> Tuple'Fused a b
Tuple'Fused (a
i a -> a -> a
forall a. Num a => a -> a -> a
- a
1) (a -> Maybe a
forall a. a -> Maybe a
Just a
a))
else Maybe a -> Step (Tuple'Fused a (Maybe a)) (Maybe a)
forall s b. b -> Step s b
Done (a -> Maybe a
forall a. a -> Maybe a
Just a
a)
extract :: Tuple'Fused a b -> b
extract (Tuple'Fused a
_ b
r) = b
r
{-# INLINE dropping #-}
dropping :: Monad m => Int -> Scanl m a (Maybe a)
dropping :: forall (m :: * -> *) a. Monad m => Int -> Scanl m a (Maybe a)
dropping Int
n = (Tuple'Fused Int (Maybe a)
-> a -> Step (Tuple'Fused Int (Maybe a)) (Maybe a))
-> Step (Tuple'Fused Int (Maybe a)) (Maybe a)
-> (Tuple'Fused Int (Maybe a) -> Maybe a)
-> Scanl m a (Maybe a)
forall (m :: * -> *) s a b.
Monad m =>
(s -> a -> Step s b) -> Step s b -> (s -> b) -> Scanl m a b
mkScant Tuple'Fused Int (Maybe a)
-> a -> Step (Tuple'Fused Int (Maybe a)) (Maybe a)
forall {a} {b} {a} {b}.
(Ord a, Num a) =>
Tuple'Fused a b -> a -> Step (Tuple'Fused a (Maybe a)) b
step Step (Tuple'Fused Int (Maybe a)) (Maybe a)
forall {a} {b}. Step (Tuple'Fused Int (Maybe a)) b
initial Tuple'Fused Int (Maybe a) -> Maybe a
forall {a} {b}. Tuple'Fused a b -> b
extract
where
initial :: Step (Tuple'Fused Int (Maybe a)) b
initial = Tuple'Fused Int (Maybe a) -> Step (Tuple'Fused Int (Maybe a)) b
forall s b. s -> Step s b
Partial (Int -> Maybe a -> Tuple'Fused Int (Maybe a)
forall a b. a -> b -> Tuple'Fused a b
Tuple'Fused Int
n Maybe a
forall a. Maybe a
Nothing)
step :: Tuple'Fused a b -> a -> Step (Tuple'Fused a (Maybe a)) b
step (Tuple'Fused a
i b
_) a
a =
if a
i a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
0
then Tuple'Fused a (Maybe a) -> Step (Tuple'Fused a (Maybe a)) b
forall s b. s -> Step s b
Partial (a -> Maybe a -> Tuple'Fused a (Maybe a)
forall a b. a -> b -> Tuple'Fused a b
Tuple'Fused (a
i a -> a -> a
forall a. Num a => a -> a -> a
- a
1) Maybe a
forall a. Maybe a
Nothing)
else Tuple'Fused a (Maybe a) -> Step (Tuple'Fused a (Maybe a)) b
forall s b. s -> Step s b
Partial (a -> Maybe a -> Tuple'Fused a (Maybe a)
forall a b. a -> b -> Tuple'Fused a b
Tuple'Fused a
i (a -> Maybe a
forall a. a -> Maybe a
Just a
a))
extract :: Tuple'Fused a b -> b
extract (Tuple'Fused a
_ b
r) = b
r
{-# INLINE take #-}
take :: Monad m => Int -> Scanl m a b -> Scanl m a b
take :: forall (m :: * -> *) a b.
Monad m =>
Int -> Scanl m a b -> Scanl m a b
take Int
n (Scanl s -> a -> m (Step s b)
fstep m (Step s b)
finitial s -> m b
fextract s -> m b
ffinal) = (Tuple'Fused Int s -> a -> m (Step (Tuple'Fused Int s) b))
-> m (Step (Tuple'Fused Int s) b)
-> (Tuple'Fused Int s -> m b)
-> (Tuple'Fused Int s -> 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'Fused Int s -> a -> m (Step (Tuple'Fused Int s) b)
step m (Step (Tuple'Fused Int s) b)
initial Tuple'Fused Int s -> m b
forall {a}. Tuple'Fused a s -> m b
extract Tuple'Fused Int s -> m b
forall {a}. Tuple'Fused a s -> m b
final
where
{-# INLINE next #-}
next :: Int -> Step s b -> m (Step (Tuple'Fused Int s) b)
next Int
i Step s b
res =
case Step s b
res of
Partial s
s -> do
let i1 :: Int
i1 = Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
s1 :: Tuple'Fused Int s
s1 = Int -> s -> Tuple'Fused Int s
forall a b. a -> b -> Tuple'Fused a b
Tuple'Fused Int
i1 s
s
if Int
i1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n
then Step (Tuple'Fused Int s) b -> m (Step (Tuple'Fused Int s) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Tuple'Fused Int s) b -> m (Step (Tuple'Fused Int s) b))
-> Step (Tuple'Fused Int s) b -> m (Step (Tuple'Fused Int s) b)
forall a b. (a -> b) -> a -> b
$ Tuple'Fused Int s -> Step (Tuple'Fused Int s) b
forall s b. s -> Step s b
Partial Tuple'Fused Int s
s1
else b -> Step (Tuple'Fused Int s) b
forall s b. b -> Step s b
Done (b -> Step (Tuple'Fused Int s) b)
-> m b -> m (Step (Tuple'Fused Int s) b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s
Done b
b -> Step (Tuple'Fused Int s) b -> m (Step (Tuple'Fused Int s) b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Step (Tuple'Fused Int s) b -> m (Step (Tuple'Fused Int s) b))
-> Step (Tuple'Fused Int s) b -> m (Step (Tuple'Fused Int s) b)
forall a b. (a -> b) -> a -> b
$ b -> Step (Tuple'Fused Int s) b
forall s b. b -> Step s b
Done b
b
initial :: m (Step (Tuple'Fused Int s) b)
initial = m (Step s b)
finitial m (Step s b)
-> (Step s b -> m (Step (Tuple'Fused Int s) b))
-> m (Step (Tuple'Fused Int s) b)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> Step s b -> m (Step (Tuple'Fused Int s) b)
next (-Int
1)
step :: Tuple'Fused Int s -> a -> m (Step (Tuple'Fused Int s) b)
step (Tuple'Fused Int
i s
r) a
a = s -> a -> m (Step s b)
fstep s
r a
a m (Step s b)
-> (Step s b -> m (Step (Tuple'Fused Int s) b))
-> m (Step (Tuple'Fused Int s) b)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> Step s b -> m (Step (Tuple'Fused Int s) b)
next Int
i
extract :: Tuple'Fused a s -> m b
extract (Tuple'Fused a
_ s
r) = s -> m b
fextract s
r
final :: Tuple'Fused a s -> m b
final (Tuple'Fused a
_ s
r) = s -> m b
ffinal s
r
{-# INLINE takeEndBy_ #-}
takeEndBy_ :: Monad m => (a -> Bool) -> Scanl m a b -> Scanl m a b
takeEndBy_ :: forall (m :: * -> *) a r.
Monad m =>
(a -> Bool) -> Scanl m a r -> Scanl m a r
takeEndBy_ a -> Bool
predicate (Scanl s -> a -> m (Step s b)
fstep m (Step s b)
finitial s -> m b
fextract s -> m b
ffinal) =
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> 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 s -> a -> m (Step s b)
step m (Step s b)
finitial s -> m b
fextract s -> m b
ffinal
where
step :: s -> a -> m (Step s b)
step s
s a
a =
if Bool -> Bool
not (a -> Bool
predicate a
a)
then s -> a -> m (Step s b)
fstep s
s a
a
else b -> Step s b
forall s b. b -> Step s b
Done (b -> Step s b) -> m b -> m (Step s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s
{-# INLINE takeEndBy #-}
takeEndBy :: Monad m => (a -> Bool) -> Scanl m a b -> Scanl m a b
takeEndBy :: forall (m :: * -> *) a r.
Monad m =>
(a -> Bool) -> Scanl m a r -> Scanl m a r
takeEndBy a -> Bool
predicate (Scanl s -> a -> m (Step s b)
fstep m (Step s b)
finitial s -> m b
fextract s -> m b
ffinal) =
(s -> a -> m (Step s b))
-> m (Step s b) -> (s -> m b) -> (s -> 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 s -> a -> m (Step s b)
step m (Step s b)
finitial s -> m b
fextract s -> m b
ffinal
where
step :: s -> a -> m (Step s b)
step s
s a
a = do
Step s b
res <- s -> a -> m (Step s b)
fstep s
s a
a
if Bool -> Bool
not (a -> Bool
predicate a
a)
then Step s b -> m (Step s b)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return Step s b
res
else do
case Step s b
res of
Partial s
s1 -> b -> Step s b
forall s b. b -> Step s b
Done (b -> Step s b) -> m b -> m (Step s b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> s -> m b
ffinal s
s1
Done b
b -> 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
$ b -> Step s b
forall s b. b -> Step s b
Done b
b
morphInner :: (forall x. m x -> n x) -> Scanl m a b -> Scanl n a b
morphInner :: forall (m :: * -> *) (n :: * -> *) a b.
(forall x. m x -> n x) -> Scanl m a b -> Scanl n a b
morphInner forall x. m x -> n x
f (Scanl s -> a -> m (Step s b)
step m (Step s b)
initial s -> m b
extract s -> m b
final) =
(s -> a -> n (Step s b))
-> n (Step s b) -> (s -> n b) -> (s -> n b) -> Scanl n 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 (\s
x a
a -> m (Step s b) -> n (Step s b)
forall x. m x -> n x
f (m (Step s b) -> n (Step s b)) -> m (Step s b) -> n (Step s b)
forall a b. (a -> b) -> a -> b
$ s -> a -> m (Step s b)
step s
x a
a) (m (Step s b) -> n (Step s b)
forall x. m x -> n x
f m (Step s b)
initial) (m b -> n b
forall x. m x -> n x
f (m b -> n b) -> (s -> m b) -> s -> n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> m b
extract) (m b -> n b
forall x. m x -> n x
f (m b -> n b) -> (s -> m b) -> s -> n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> m b
final)
generalizeInner :: Monad m => Scanl Identity a b -> Scanl m a b
generalizeInner :: forall (m :: * -> *) a b.
Monad m =>
Scanl Identity a b -> Scanl m a b
generalizeInner = (forall x. Identity x -> m x) -> Scanl Identity a b -> Scanl m a b
forall (m :: * -> *) (n :: * -> *) a b.
(forall x. m x -> n x) -> Scanl m a b -> Scanl n a b
morphInner (x -> m x
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (x -> m x) -> (Identity x -> x) -> Identity x -> m x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity x -> x
forall a. Identity a -> a
runIdentity)