module Fold.Effectful.Conversion where
import Fold.Effectful.Type
import Control.Monad (Monad)
import Data.Maybe (Maybe)
import Fold.Nonempty.Type (NonemptyFold)
import qualified Control.Applicative as Applicative
import qualified Fold.Pure.Conversion as Pure
import qualified Fold.Pure.Type as Pure
fold :: Monad m => Pure.Fold a b -> EffectfulFold m a b
fold :: forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold Pure.Fold{ x
initial :: ()
initial :: x
Pure.initial, x -> a -> x
step :: ()
step :: x -> a -> x
Pure.step, x -> b
extract :: ()
extract :: x -> b
Pure.extract } = EffectfulFold
{ initial :: m x
initial = forall (f :: * -> *) a. Applicative f => a -> f a
Applicative.pure ( x
initial )
, step :: x -> a -> m x
step = \x
x a
a -> forall (f :: * -> *) a. Applicative f => a -> f a
Applicative.pure ( x -> a -> x
step x
x a
a )
, extract :: x -> m b
extract = \x
x -> forall (f :: * -> *) a. Applicative f => a -> f a
Applicative.pure ( x -> b
extract x
x )
}
nonemptyFold :: Monad m => NonemptyFold a b -> EffectfulFold m a (Maybe b)
nonemptyFold :: forall (m :: * -> *) a b.
Monad m =>
NonemptyFold a b -> EffectfulFold m a (Maybe b)
nonemptyFold NonemptyFold a b
x = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold (forall a b. NonemptyFold a b -> Fold a (Maybe b)
Pure.nonemptyFold NonemptyFold a b
x)