Control.Proxy.ListT

This module implements "ListT done right" in terms of proxies.

The RespondT monad transformer is the ListT monad transformer over the downstream output type. Each respond corresponds to an element of the list. The monad bind operation non-deterministically selects one of the previous responds as input. The RespondT Kleisli category corresponds to the "respond" category of the ListT class.

Symmetrically, the RequestT monad transformer is the ListT monad transformer over the upstream output type. Each request corresponds to an element of the list. The monad bind operation non-deterministically selects one of the previous requests as input. The RequestT Kleisli category corresponds to the "request" category of the ListT class.

Unlike ListT from transformers, these monad transformers are correct by construction and always satisfy the monad and monad transformer laws.

Respond Monad Transformer

newtype RespondT p a' a b' m b

A monad transformer over a proxy's downstream output

Constructors

RespondT

Fields

runRespondT :: p a' a b' b m b'

Instances

ListT p => MonadTrans (RespondT p a' a b')

(Monad m, ListT p) => Monad (RespondT p a' a b' m)

(Monad m, ListT p) => Functor (RespondT p a' a b' m)

(Monad m, ListT p, Monoid b') => MonadPlus (RespondT p a' a b' m)

(Monad m, ListT p) => Applicative (RespondT p a' a b' m)

(Monad m, ListT p, Monoid b') => Alternative (RespondT p a' a b' m)

(MonadIO m, ListT p) => MonadIO (RespondT p a' a b' m)

runRespondK :: (q -> RespondT p a' a b' m b) -> q -> p a' a b' b m b'

Convert a RespondT 'K'leisli arrow into a proxy

type ProduceT p = RespondT p C () ()

ProduceT is isomorphic to "ListT done right"

Request Monad Transformer

newtype RequestT p a b' b m a'

A monad transformer over a proxy's upstream output

Constructors

RequestT

Fields

runRequestT :: p a' a b' b m a

Instances

ListT p => MonadTrans (RequestT p a' a b')

(Monad m, ListT p) => Monad (RequestT p a b' b m)

(Monad m, ListT p) => Functor (RequestT p a b' b m)

(Monad m, ListT p, Monoid a) => MonadPlus (RequestT p a b' b m)

(Monad m, ListT p) => Applicative (RequestT p a b' b m)

(Monad m, ListT p, Monoid a) => Alternative (RequestT p a b' b m)

(MonadIO m, ListT p) => MonadIO (RequestT p a b' b m)

runRequestK :: (q -> RequestT p a b' b m a') -> q -> p a' a b' b m a

Convert a RequestT 'K'leisli arrow into a proxy

type CoProduceT p = RequestT p () () C

CoProduceT is isomorphic to "ListT done right"

ListT

class Proxy p => ListT p where

The two generalized "ListT" categories

Methods

(>\\) :: Monad m => (b' -> p a' a x' x m b) -> p b' b x' x m c -> p a' a x' x m c

f >\\ p replaces all requests in p with f.

Equivalent to to (=<<) for RequestT

Point-ful version of (\>\)

(//>) :: Monad m => p x' x b' b m a' -> (b -> p x' x c' c m b') -> p x' x c' c m a'

p //> f replaces all responds in p with f.

Equivalent to (>>=) for RespondT

Point-ful version of (/>/)

Instances

ListT ProxyFast

ListT ProxyCorrect

ListT p => ListT (IdentityP p)

ListT p => ListT (CodensityP p)

ListT p => ListT (ReaderP i p)

(\>\) :: (Monad m, ListT p) => (b' -> p a' a x' x m b) -> (_c' -> p b' b x' x m c) -> _c' -> p a' a x' x m c

f \>\ g replaces all requests in g with f.

Equivalent to (<=<) for RequestT

Point-free version of (>\\)

(/>/) :: (Monad m, ListT p) => (_a -> p x' x b' b m a') -> (b -> p x' x c' c m b') -> _a -> p x' x c' c m a'

f />/ g replaces all responds in f with g.

Equivalent to (>=>) for RespondT

Point-free version of (//>)

Flipped operators

(/</) :: (Monad m, ListT p) => (_c' -> p b' b x' x m c) -> (b' -> p a' a x' x m b) -> _c' -> p a' a x' x m c

Equivalent to (\>\) with the arguments flipped

(\<\) :: (Monad m, ListT p) => (b -> p x' x c' c m b') -> (_a -> p x' x b' b m a') -> _a -> p x' x c' c m a'

Equivalent to (/>/) with the arguments flipped

(//<) :: (Monad m, ListT p) => p b' b x' x m c -> (b' -> p a' a x' x m b) -> p a' a x' x m c

Equivalent to (>\\) with the arguments flipped

(<\\) :: (Monad m, ListT p) => (b -> p x' x c' c m b') -> p x' x b' b m a' -> p x' x c' c m a'

Equivalent to (//>) with the arguments flipped

Laws

The ListT class defines the ability to:

• Replace existing request commands using (\>\)
• Replace existing respond commands using (/>/)

Laws:

• (/>/) and respond form a ListT Kleisli category:

 return = respond

 (>=>) = (//>)

• (\>\) and request also form a ListT Kleisli category:

 return = request

 (>>=) = (//<)

Additionally, (\>\) and (/>/) both define functors between Proxy Kleisli categories:

 a \>\ (b >=> c) = (a \>\ b) >=> (a \>\ c)

 a \>\ return = return

 (b >=> c) />/ a = (b />/ a) >=> (c />/ a)

 return />/ a = return