Control.Monad.Ran

Contents

A right Kan extension monad transformer
Representing monads as right Kan extensions
Ran Monad Transformers
Default definitions for common extension patterns
IO, ST s, STM
Pointed Functors
The Yoneda Lemma
The codensity monad of a functor

Synopsis

data Ran m a = Ran {

getRan :: forall b. (a -> G m b) -> H m b

}

class (Applicative (Ran f), Applicative f, RanIso f) => RApplicative f

class (Monad (Ran f), Monad f, RanIso f) => RMonad f

class RanIso f where

type G f :: * -> *

type H f :: * -> *

liftRan :: f a -> Ran f a

lowerRan :: Ran f a -> f a

class RanTrans t where

liftRanT :: (RanIso m, RanIso (t m)) => Ran m a -> Ran (t m) a

outRan :: (RanIso m, RanIso (t m)) => Ran (t m) a -> t (Ran m) a

inRan :: (RanIso m, RanIso (t m)) => t (Ran m) a -> Ran (t m) a

returnRanCodensity :: (RanIso m, G m ~ H m) => a -> Ran m a

bindRanCodensity :: (RanIso m, G m ~ H m) => Ran m a -> (a -> Ran m b) -> Ran m b

apRanCodensity :: (RanIso m, G m ~ H m) => Ran m (a -> b) -> Ran m a -> Ran m b

ranCodensity :: Ran (Codensity f) a -> Codensity f a

codensityRan :: Codensity f a -> Ran (Codensity f) a

liftRanCodensity :: (RanIso m, G m ~ H m, Monad (G m)) => G m a -> Ran m a

lowerRanCodensity :: (RanIso m, G m ~ H m, Monad (G m)) => Ran m a -> G m a

liftRanWorld :: (G m ~ World w, H m ~ World w) => (State# w -> (#State# w, a#)) -> Ran m a

lowerRanWorld :: (G m ~ World w, H m ~ World w) => Ran m a -> State# w -> (#State# w, a#)

class Functor f => Pointed f where

point :: a -> f a

data Yoneda f a = Yoneda {

getYoneda :: forall b. (a -> b) -> f b

}

lowerYoneda :: Yoneda f a -> f a

data Codensity f a = Codensity {

getCodensity :: forall b. (a -> f b) -> f b

}

lowerCodensity :: Monad m => Codensity m a -> m a

lowerCodensityApp :: Applicative f => Codensity f a -> f a

lowerCodensityPointed :: Applicative f => Codensity f a -> f a

A right Kan extension monad transformer

data Ran m a

Source

A right Kan extension transformer for a monad

Constructors

Ran

getRan :: forall b. (a -> G m b) -> H m b

Instances

MonadRWS r w s m => MonadRWS r w s (Ran (Codensity m))

(RMonad m, Error e, MonadRWS r w s (Ran m)) => MonadRWS r w s (Ran (ErrorT e m))

MonadRWS r w s f => MonadRWS r w s (Ran (Yoneda f))

MonadError e m => MonadError e (Ran (Codensity m))

Error e => MonadError e (Ran (Either e))

MonadError e f => MonadError e (Ran (Yoneda f))

MonadError IOError (Ran IO)

MonadReader r m => MonadReader r (Ran (Codensity m))

(RMonad m, Error e, MonadReader r (Ran m)) => MonadReader r (Ran (ErrorT e m))

RMonad m => MonadReader r (Ran (ReaderT r m))

MonadReader e (Ran (Reader e))

MonadReader e (Ran ((->) e))

MonadReader r f => MonadReader r (Ran (Yoneda f))

MonadState s m => MonadState s (Ran (Codensity m))

(RMonad m, Error e, MonadState s (Ran m)) => MonadState s (Ran (ErrorT e m))

(RMonad m, MonadState s (Ran m)) => MonadState s (Ran (ReaderT e m))

MonadState s f => MonadState s (Ran (Yoneda f))

MonadState s (Ran (State s))

MonadWriter w m => MonadWriter w (Ran (Codensity m))

(RMonad m, Error e, MonadWriter w (Ran m)) => MonadWriter w (Ran (ErrorT e m))

(RMonad m, MonadWriter w (Ran m)) => MonadWriter w (Ran (ReaderT e m))

MonadWriter w f => MonadWriter w (Ran (Yoneda f))

Monoid w => MonadWriter w (Ran (Writer w))

Monad (Ran ((->) e))

Monad (Ran IO)

Error e => Monad (Ran (Either e))

Monad (Ran STM)

Monad (Ran (ST s))

Monad (Ran Maybe)

Monoid w => Monad (Ran (Writer w))

Monad (Ran (State s))

Monad (Ran (Reader e))

RMonad m => Monad (Ran (ReaderT e m))

(RMonad m, Error e) => Monad (Ran (ErrorT e m))

Monad (Ran Identity)

Monad f => Monad (Ran (Yoneda f))

Monad (Ran (Codensity f))

RanIso f => Functor (Ran f)

MonadFix (Ran IO)

Error e => MonadFix (Ran (Either e))

MonadFix (Ran (ST s))

MonadFix (Ran Maybe)

(RMonad m, MonadFix (Ran m)) => MonadFix (Ran (ReaderT e m))

(RMonad m, Error e, MonadFix (Ran m)) => MonadFix (Ran (ErrorT e m))

MonadFix m => MonadFix (Ran (Yoneda m))

MonadFix m => MonadFix (Ran (Codensity m))

MonadPlus (Ran IO)

Error e => MonadPlus (Ran (Either e))

MonadPlus (Ran Maybe)

(RMonad m, MonadPlus (Ran m)) => MonadPlus (Ran (ReaderT e m))

MonadPlus f => MonadPlus (Ran (Yoneda f))

MonadPlus f => MonadPlus (Ran (Codensity f))

Applicative (Ran ((->) e))

Applicative (Ran IO)

Applicative (Ran STM)

Applicative (Ran (ST s))

Applicative (Ran Maybe)

Monoid w => Applicative (Ran (Writer w))

Applicative (Ran (State s))

Applicative (Ran (Reader e))

RMonad m => Applicative (Ran (ReaderT e m))

(RMonad m, Error e) => Applicative (Ran (ErrorT e m))

Applicative (Ran Identity)

Applicative f => Applicative (Ran (Yoneda f))

Applicative (Ran (Codensity f))

(RMonad m, MonadPlus (Ran m)) => Alternative (Ran (ReaderT e m))

(RMonad m, Error e, MonadPlus (Ran m)) => Alternative (Ran (ErrorT e m))

Alternative f => Alternative (Ran (Yoneda f))

Alternative (Codensity f) => Alternative (Ran (Codensity f))

MonadIO (Ran IO)

(RMonad m, MonadIO (Ran m)) => MonadIO (Ran (ReaderT e m))

(RMonad m, Error e, MonadIO (Ran m)) => MonadIO (Ran (ErrorT e m))

MonadIO f => MonadIO (Ran (Yoneda f))

MonadIO f => MonadIO (Ran (Codensity f))

Pointed (Ran ((->) e))

Monoid w => Pointed (Ran (Writer w))

Pointed (Ran (State s))

Pointed (Ran (Reader e))

RMonad m => Pointed (Ran (ReaderT e m))

(RMonad m, Error e) => Pointed (Ran (ErrorT e m))

Pointed (Ran Identity)

Pointed f => Pointed (Ran (Yoneda f))

Pointed (Ran (Codensity f))

(Eq a, Eq b) => Eq (Ran (Either a) b)

Eq a => Eq (Ran Maybe a)

(RanIso m, Eq (Ran m (Either a b))) => Eq (Ran (ErrorT a m) b)

Eq a => Eq (Ran Identity a)

(Ord a, Ord b) => Ord (Ran (Either a) b)

Ord a => Ord (Ran Maybe a)

(RanIso m, Ord (Ran m (Either a b))) => Ord (Ran (ErrorT a m) b)

Ord a => Ord (Ran Identity a)

(Read a, Read b) => Read (Ran (Either a) b)

Read a => Read (Ran Maybe a)

(RanIso m, Read (Ran m (Either a b))) => Read (Ran (ErrorT a m) b)

Read a => Read (Ran Identity a)

(Show a, Show b) => Show (Ran (Either a) b)

Show a => Show (Ran Maybe a)

(RanIso m, Show (Ran m (Either a b))) => Show (Ran (ErrorT a m) b)

Show a => Show (Ran Identity a)

Monoid m => Monoid (Ran ((->) e) m)

Monoid a => Monoid (Ran Maybe a)

Monoid m => Monoid (Ran (Reader e) m)

Representing monads as right Kan extensions

class (Applicative (Ran f), Applicative f, RanIso f) => RApplicative f

Source

class (Monad (Ran f), Monad f, RanIso f) => RMonad f

Source

class RanIso f where

Source

Associated Types

type G f :: * -> *

Source

type H f :: * -> *

Source

Methods

liftRan :: f a -> Ran f a

Source

lowerRan :: Ran f a -> f a

Instances

RanIso ((->) e)

RanIso (Either e)

RanIso (ST s)

Monoid w => RanIso (Writer w)

RanIso (State s)

RanIso (Reader e)

RanIso (Yoneda f)

RanIso (Codensity f)

RanIso m => RanIso (ReaderT e m)

(RanIso m, Error e) => RanIso (ErrorT e m)

Ran Monad Transformers

class RanTrans t where

Source

Methods

liftRanT :: (RanIso m, RanIso (t m)) => Ran m a -> Ran (t m) a

Source

outRan :: (RanIso m, RanIso (t m)) => Ran (t m) a -> t (Ran m) a

Source

inRan :: (RanIso m, RanIso (t m)) => t (Ran m) a -> Ran (t m) a

Source

Instances

RanTrans (ReaderT e)

RanTrans (ErrorT e)

Default definitions for common extension patterns

returnRanCodensity :: (RanIso m, G m ~ H m) => a -> Ran m a

Source

bindRanCodensity :: (RanIso m, G m ~ H m) => Ran m a -> (a -> Ran m b) -> Ran m b

Source

apRanCodensity :: (RanIso m, G m ~ H m) => Ran m (a -> b) -> Ran m a -> Ran m b

Source

ranCodensity :: Ran (Codensity f) a -> Codensity f a

Source

codensityRan :: Codensity f a -> Ran (Codensity f) a

Source

liftRanCodensity :: (RanIso m, G m ~ H m, Monad (G m)) => G m a -> Ran m a

Source

lowerRanCodensity :: (RanIso m, G m ~ H m, Monad (G m)) => Ran m a -> G m a

Source

IO, ST s, STM

liftRanWorld :: (G m ~ World w, H m ~ World w) => (State# w -> (#State# w, a#)) -> Ran m a

Source

lowerRanWorld :: (G m ~ World w, H m ~ World w) => Ran m a -> State# w -> (#State# w, a#)

Source

Pointed Functors

class Functor f => Pointed f where

Source

A pointed functor is a functor with a discriminated family of f-coalgebras

Methods

point :: a -> f a

Source

Instances

Pointed []

Pointed Maybe

Pointed Identity

Pointed ((->) r)

Pointed (Either a)

Pointed (Cont r)

Monoid w => Pointed (Writer w)

Pointed (State w)

Pointed (Reader r)

Monad m => Pointed (ListT m)

Pointed f => Pointed (Yoneda f)

Pointed (Codensity f)

Pointed (Ran ((->) e))

Monoid w => Pointed (Ran (Writer w))

Pointed (Ran (State s))

Pointed (Ran (Reader e))

RMonad m => Pointed (Ran (ReaderT e m))

(RMonad m, Error e) => Pointed (Ran (ErrorT e m))

Pointed (Ran Identity)

Pointed f => Pointed (Ran (Yoneda f))

Pointed (Ran (Codensity f))

Monad m => Pointed (ContT r m)

(Monoid w, Monad m) => Pointed (WriterT w m)

Monad m => Pointed (StateT w m)

Monad m => Pointed (ReaderT r m)

(Error e, Monad m) => Pointed (ErrorT e m)

Monoid w => Pointed (RWS r w s)

(Monoid w, Monad m) => Pointed (RWST r w s m)

The Yoneda Lemma

data Yoneda f a

Source

The Covariant Yoneda lemma applied to a functor. Note that f need not be a Hask Functor!

Constructors

Yoneda

getYoneda :: forall b. (a -> b) -> f b

Instances

MonadTrans Yoneda

MonadRWS r w s f => MonadRWS r w s (Yoneda f)

MonadError e f => MonadError e (Yoneda f)

MonadReader r f => MonadReader r (Yoneda f)

MonadState s f => MonadState s (Yoneda f)

MonadWriter w f => MonadWriter w (Yoneda f)

Monad f => Monad (Yoneda f)

Functor (Yoneda f)

MonadFix m => MonadFix (Yoneda m)

MonadPlus f => MonadPlus (Yoneda f)

Applicative f => Applicative (Yoneda f)

Alternative f => Alternative (Yoneda f)

MonadIO f => MonadIO (Yoneda f)

Pointed f => Pointed (Yoneda f)

RanIso (Yoneda f)

lowerYoneda :: Yoneda f a -> f a

Source

The codensity monad of a functor

data Codensity f a

Source

The Codensity monad of a functor/monad generated by a functor

Constructors

Codensity

getCodensity :: forall b. (a -> f b) -> f b

Instances

MonadTrans Codensity

MonadRWS r w s m => MonadRWS r w s (Codensity m)

MonadError e m => MonadError e (Codensity m)

MonadReader r m => MonadReader r (Codensity m)

MonadState s m => MonadState s (Codensity m)

MonadWriter w m => MonadWriter w (Codensity m)

Monad (Codensity f)

Functor (Codensity k)

MonadFix f => MonadFix (Codensity f)

MonadPlus m => MonadPlus (Codensity m)

Applicative (Codensity f)

MonadIO m => MonadIO (Codensity m)

Pointed (Codensity f)

RanIso (Codensity f)

lowerCodensity :: Monad m => Codensity m a -> m a

Source

lowerCodensityApp :: Applicative f => Codensity f a -> f a

Source

lowerCodensityPointed :: Applicative f => Codensity f a -> f a

Source

Produced by Haddock version 2.4.2