module Iri.MonadPlus where

import Iri.Prelude hiding (foldl)
import Ptr.ByteString qualified as ByteString
import Ptr.Poking qualified as Poking

{-# INLINE foldl #-}
foldl :: (MonadPlus m) => (a -> b -> a) -> a -> m b -> m a
foldl :: forall (m :: * -> *) a b.
MonadPlus m =>
(a -> b -> a) -> a -> m b -> m a
foldl a -> b -> a
step a
start m b
elementParser =
  a -> m a
loop a
start
  where
    loop :: a -> m a
loop a
state =
      m a -> m a -> m a
forall a. m a -> m a -> m a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus
        ( do
            b
element <- m b
elementParser
            a -> m a
loop (a -> m a) -> a -> m a
forall a b. (a -> b) -> a -> b
$! a -> b -> a
step a
state b
element
        )
        (a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
state)

{-# INLINE foldlM #-}
foldlM :: (MonadPlus m) => (a -> b -> m a) -> a -> m b -> m a
foldlM :: forall (m :: * -> *) a b.
MonadPlus m =>
(a -> b -> m a) -> a -> m b -> m a
foldlM a -> b -> m a
step a
start m b
elementParser =
  a -> m a
loop a
start
  where
    loop :: a -> m a
loop a
state =
      m (m a) -> m a
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join
        ( m (m a) -> m (m a) -> m (m a)
forall a. m a -> m a -> m a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus
            ( do
                b
element <- m b
elementParser
                m a -> m (m a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b -> m a
step a
state b
element m a -> (a -> m a) -> m a
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> m a
loop)
            )
            (m a -> m (m a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
state))
        )

{-# INLINE foldByteString #-}
foldByteString :: (MonadPlus m) => m ByteString -> m ByteString
foldByteString :: forall (m :: * -> *). MonadPlus m => m ByteString -> m ByteString
foldByteString =
  (Poking -> ByteString) -> m Poking -> m ByteString
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Poking -> ByteString
ByteString.poking
    (m Poking -> m ByteString)
-> (m ByteString -> m Poking) -> m ByteString -> m ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. (Poking -> ByteString -> Poking)
-> Poking -> m ByteString -> m Poking
forall (m :: * -> *) a b.
MonadPlus m =>
(a -> b -> a) -> a -> m b -> m a
foldl (\Poking
poking -> Poking -> Poking -> Poking
forall a. Monoid a => a -> a -> a
mappend Poking
poking (Poking -> Poking)
-> (ByteString -> Poking) -> ByteString -> Poking
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteString -> Poking
Poking.bytes) Poking
forall a. Monoid a => a
mempty

{-# INLINE fold #-}
fold :: (MonadPlus m, Monoid a) => m a -> m a
fold :: forall (m :: * -> *) a. (MonadPlus m, Monoid a) => m a -> m a
fold = (a -> a -> a) -> a -> m a -> m a
forall (m :: * -> *) a b.
MonadPlus m =>
(a -> b -> a) -> a -> m b -> m a
foldl a -> a -> a
forall a. Monoid a => a -> a -> a
mappend a
forall a. Monoid a => a
mempty