Algebra.Monad.Base

Documentation

module Algebra.Classes

module Algebra.Applicative

module Algebra.Core

module Algebra.Traversable

module Algebra.Lens

Monad utilities

newtype Kleisli m a b

Constructors

Kleisli

Fields

runKleisli :: a -> m b

Instances

Monad m => Split (Kleisli m)

Monad m => Choice (Kleisli m)

Monad m => Category (Kleisli m)

Monad m => Apply (Kleisli m)

Monad m => Arrow (Kleisli m)

Functor f => Functor (Kleisli f a)

Contravariant f => Contravariant (Kleisli f a)

Isomorphic (a -> m b) (c -> m' d) (Kleisli m a b) (Kleisli m' c d)

i'Kleisli :: Iso (Kleisli m a b) (Kleisli m' c d) (a -> m b) (c -> m' d)

(=<<) :: Monad m => (a -> m b) -> m a -> m b

joinMap :: Monad m => (a -> m b) -> m a -> m b

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c

(>>) :: Applicative f => f a -> f b -> f b

(<*=) :: Monad m => m a -> (a -> m b) -> m a

only :: (Monoid (m ()), Monad m) => (a -> Bool) -> m a -> m a

return :: Unit f => a -> f a

foldlM :: (Foldable t, Monad m) => (a -> b -> m a) -> a -> t b -> m a

foldrM :: (Foldable t, Monad m) => (b -> a -> m a) -> t b -> a -> m a

findM :: (Foldable t, Monad m) => (a -> m (Maybe b)) -> t a -> m (Maybe b)

while :: Monad m => m Bool -> m ()

until :: Monad m => m (Maybe a) -> m a

bind2 :: Monad m => (a -> b -> m c) -> m a -> m b -> m c

bind3 :: Monad m => (a -> b -> c -> m d) -> m a -> m b -> m c -> m d

(>>>=) :: Monad m => (m a, m b) -> (a -> b -> m c) -> m c

(>>>>=) :: Monad m => (m a, m b, m c) -> (a -> b -> c -> m d) -> m d

Monadic Lenses

type Action s t a b = forall m. Monad m => LensLike m s t a b

type Action' a b = Action b b a a

Instance utilities

newtype Compose' f g a

Constructors

Compose' ((g :.: f) a)

Instances

Monad m => ConcreteMonad (Compose' m)

Monad m => MonadTrans (Compose' m)

(Unit f, Unit g) => Unit (Compose' f g)

(MonadFix g, Traversable f, Monad f) => MonadFix (Compose' f g)

(Traversable f, Traversable g) => Traversable (Compose' f g)

(Foldable f, Foldable g) => Foldable (Compose' f g)

(Traversable f, Monad f, Monad g) => Monad (Compose' f g)

(Applicative f, Applicative g) => Applicative (Compose' f g)

(Functor f, Functor g) => Functor (Compose' f g)

(Monoid (f a), Applicative g) => Monoid (Compose' f g a)

(Semigroup (f a), Applicative g) => Semigroup (Compose' f g a)

i'Compose' :: Iso (Compose' f g a) (Compose' h i b) (g (f a)) (i (h b))