module Fold.Effectful.Pure
(
monoid,
null, length,
and, or, all, any,
sum, product, mean, variance, standardDeviation,
element, notElement, find, lookup,
index, findIndex, elementIndex,
list, reverseList,
)
where
import Control.Monad (Monad)
import Data.Bool (Bool)
import Data.Eq (Eq)
import Data.Maybe (Maybe)
import Data.Monoid (Monoid)
import Fold.Effectful.Conversion (fold)
import Fold.Effectful.Type (EffectfulFold)
import Numeric.Natural (Natural)
import Prelude (Floating, Fractional, Num)
import qualified Fold.Pure.Examples as Pure
monoid :: Monoid a => Monad m => EffectfulFold m a a
monoid :: forall a (m :: * -> *). (Monoid a, Monad m) => EffectfulFold m a a
monoid = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold forall a. Monoid a => Fold a a
Pure.monoid
null :: Monad m => EffectfulFold m a Bool
null :: forall (m :: * -> *) a. Monad m => EffectfulFold m a Bool
null = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold forall a. Fold a Bool
Pure.null
length :: Monad m => EffectfulFold m a Natural
length :: forall (m :: * -> *) a. Monad m => EffectfulFold m a Natural
length = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold forall a. Fold a Natural
Pure.length
and :: Monad m => EffectfulFold m Bool Bool
and :: forall (m :: * -> *). Monad m => EffectfulFold m Bool Bool
and = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold Fold Bool Bool
Pure.and
or :: Monad m => EffectfulFold m Bool Bool
or :: forall (m :: * -> *). Monad m => EffectfulFold m Bool Bool
or = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold Fold Bool Bool
Pure.or
all :: Monad m => (a -> Bool) -> EffectfulFold m a Bool
all :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> EffectfulFold m a Bool
all a -> Bool
predicate = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold (forall a. (a -> Bool) -> Fold a Bool
Pure.all a -> Bool
predicate)
any :: Monad m => (a -> Bool) -> EffectfulFold m a Bool
any :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> EffectfulFold m a Bool
any a -> Bool
predicate = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold (forall a. (a -> Bool) -> Fold a Bool
Pure.any a -> Bool
predicate)
sum :: Num a => Monad m => EffectfulFold m a a
sum :: forall a (m :: * -> *). (Num a, Monad m) => EffectfulFold m a a
sum = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold forall a. Num a => Fold a a
Pure.sum
product :: Num a => Monad m => EffectfulFold m a a
product :: forall a (m :: * -> *). (Num a, Monad m) => EffectfulFold m a a
product = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold forall a. Num a => Fold a a
Pure.product
mean :: Fractional a => Monad m => EffectfulFold m a a
mean :: forall a (m :: * -> *).
(Fractional a, Monad m) =>
EffectfulFold m a a
mean = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold forall a. Fractional a => Fold a a
Pure.mean
variance :: Fractional a => Monad m => EffectfulFold m a a
variance :: forall a (m :: * -> *).
(Fractional a, Monad m) =>
EffectfulFold m a a
variance = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold forall a. Fractional a => Fold a a
Pure.variance
standardDeviation :: Floating a => Monad m => EffectfulFold m a a
standardDeviation :: forall a (m :: * -> *).
(Floating a, Monad m) =>
EffectfulFold m a a
standardDeviation = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold forall a. Floating a => Fold a a
Pure.standardDeviation
element :: Eq a => Monad m => a -> EffectfulFold m a Bool
element :: forall a (m :: * -> *).
(Eq a, Monad m) =>
a -> EffectfulFold m a Bool
element a
a = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold (forall a. Eq a => a -> Fold a Bool
Pure.element a
a)
notElement :: Eq a => Monad m => a -> EffectfulFold m a Bool
notElement :: forall a (m :: * -> *).
(Eq a, Monad m) =>
a -> EffectfulFold m a Bool
notElement a
a = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold (forall a. Eq a => a -> Fold a Bool
Pure.notElement a
a)
find :: Monad m => (a -> Bool) -> EffectfulFold m a (Maybe a)
find :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> EffectfulFold m a (Maybe a)
find a -> Bool
ok = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold (forall a. (a -> Bool) -> Fold a (Maybe a)
Pure.find a -> Bool
ok)
index :: Monad m => Natural -> EffectfulFold m a (Maybe a)
index :: forall (m :: * -> *) a.
Monad m =>
Natural -> EffectfulFold m a (Maybe a)
index Natural
i = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold (forall a. Natural -> Fold a (Maybe a)
Pure.index Natural
i)
elementIndex :: Eq a => Monad m => a -> EffectfulFold m a (Maybe Natural)
elementIndex :: forall a (m :: * -> *).
(Eq a, Monad m) =>
a -> EffectfulFold m a (Maybe Natural)
elementIndex a
a = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold (forall a. Eq a => a -> Fold a (Maybe Natural)
Pure.elementIndex a
a)
findIndex :: Monad m => (a -> Bool) -> EffectfulFold m a (Maybe Natural)
findIndex :: forall (m :: * -> *) a.
Monad m =>
(a -> Bool) -> EffectfulFold m a (Maybe Natural)
findIndex a -> Bool
ok = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold (forall a. (a -> Bool) -> Fold a (Maybe Natural)
Pure.findIndex a -> Bool
ok)
lookup :: Eq a => Monad m => a -> EffectfulFold m (a, b) (Maybe b)
lookup :: forall a (m :: * -> *) b.
(Eq a, Monad m) =>
a -> EffectfulFold m (a, b) (Maybe b)
lookup a
a = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold (forall a b. Eq a => a -> Fold (a, b) (Maybe b)
Pure.lookup a
a)
list :: Monad m => EffectfulFold m a [a]
list :: forall (m :: * -> *) a. Monad m => EffectfulFold m a [a]
list = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold forall a. Fold a [a]
Pure.list
reverseList :: Monad m => EffectfulFold m a [a]
reverseList :: forall (m :: * -> *) a. Monad m => EffectfulFold m a [a]
reverseList = forall (m :: * -> *) a b.
Monad m =>
Fold a b -> EffectfulFold m a b
fold forall a. Fold a [a]
Pure.reverseList