Control.Proxy.Class

This module provides an abstract interface to Proxy-like behavior, so that multiple proxy implementations can share the same library of utility proxies.

Proxy composition

class Channel p where

The Channel class defines an interface to a bidirectional flow of information.

Laws:

• (>->) and idT form a category:

idT >-> f = f

f >-> idT = f

(f >-> g) >-> h = f >-> (g >-> h)

Minimal complete definition:

• idT
• (>->) or (<-<).

Minimal complete definition

idT

Methods

idT :: Monad m => a' -> p a' a a' a m r

idT acts like a 'T'ransparent proxy, passing all requests further upstream, and passing all responses further downstream.

(>->) :: Monad m => (b' -> p a' a b' b m r) -> (c' -> p b' b c' c m r) -> c' -> p a' a c' c m r infixl 7

Compose two proxies, satisfying all requests from downstream with responses from upstream.

(<-<) :: Monad m => (c' -> p b' b c' c m r) -> (b' -> p a' a b' b m r) -> c' -> p a' a c' c m r infixr 7

Compose two proxies, satisfying all requests from downstream with responses from upstream.

Instances

Channel Proxy

Methods

idT :: Monad m => a' -> Proxy a' a a' a m r

(>->) :: Monad m => (b' -> Proxy a' a b' b m r) -> (c' -> Proxy b' b c' c m r) -> c' -> Proxy a' a c' c m r

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

Channel p => Channel (IdentityP p)

Methods

idT :: Monad m => a' -> IdentityP p a' a a' a m r

(>->) :: Monad m => (b' -> IdentityP p a' a b' b m r) -> (c' -> IdentityP p b' b c' c m r) -> c' -> IdentityP p a' a c' c m r

(<-<) :: Monad m => (c' -> IdentityP p b' b c' c m r) -> (b' -> IdentityP p a' a b' b m r) -> c' -> IdentityP p a' a c' c m r

Channel p => Channel (MaybeP p)

Methods

idT :: Monad m => a' -> MaybeP p a' a a' a m r

(>->) :: Monad m => (b' -> MaybeP p a' a b' b m r) -> (c' -> MaybeP p b' b c' c m r) -> c' -> MaybeP p a' a c' c m r

(<-<) :: Monad m => (c' -> MaybeP p b' b c' c m r) -> (b' -> MaybeP p a' a b' b m r) -> c' -> MaybeP p a' a c' c m r

Channel p => Channel (EitherP e p)

Methods

idT :: Monad m => a' -> EitherP e p a' a a' a m r

(>->) :: Monad m => (b' -> EitherP e p a' a b' b m r) -> (c' -> EitherP e p b' b c' c m r) -> c' -> EitherP e p a' a c' c m r

(<-<) :: Monad m => (c' -> EitherP e p b' b c' c m r) -> (b' -> EitherP e p a' a b' b m r) -> c' -> EitherP e p a' a c' c m r

Channel p => Channel (ReaderP i p)

Methods

idT :: Monad m => a' -> ReaderP i p a' a a' a m r

(>->) :: Monad m => (b' -> ReaderP i p a' a b' b m r) -> (c' -> ReaderP i p b' b c' c m r) -> c' -> ReaderP i p a' a c' c m r

(<-<) :: Monad m => (c' -> ReaderP i p b' b c' c m r) -> (b' -> ReaderP i p a' a b' b m r) -> c' -> ReaderP i p a' a c' c m r

Channel p => Channel (StateP s p)

Methods

idT :: Monad m => a' -> StateP s p a' a a' a m r

(>->) :: Monad m => (b' -> StateP s p a' a b' b m r) -> (c' -> StateP s p b' b c' c m r) -> c' -> StateP s p a' a c' c m r

(<-<) :: Monad m => (c' -> StateP s p b' b c' c m r) -> (b' -> StateP s p a' a b' b m r) -> c' -> StateP s p a' a c' c m r

Channel p => Channel (WriterP w p)

Methods

idT :: Monad m => a' -> WriterP w p a' a a' a m r

(>->) :: Monad m => (b' -> WriterP w p a' a b' b m r) -> (c' -> WriterP w p b' b c' c m r) -> c' -> WriterP w p a' a c' c m r

(<-<) :: Monad m => (c' -> WriterP w p b' b c' c m r) -> (b' -> WriterP w p a' a b' b m r) -> c' -> WriterP w p a' a c' c m r

Proxy request and respond

class Interact p where

The Interact class defines the ability to:

• Request input using the request command
• Replace existing request commands using (\>\)
• Respond with output using the respond command
• Replace existing respond commands using (/>/)

Laws:

• (\>\) and request form a category:

request \>\ f = f

f \>\ request = f

(f \>\ g) \>\ h = f \>\ (g \>\ h)

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

respond />/ f = f

f />/ respond = f

(f />/ g) />/ h = f />/ (g />/ h)

Minimal complete definition:

• request,
• (\>\) or (/</),
• respond, and
• (/>/) or (\<\).

Minimal complete definition

request, respond

Methods

request :: Monad m => a' -> p a' a x' x m a

request input from upstream, passing an argument with the request

request a' passes a' as a parameter to upstream that upstream may use to decide what response to return. request binds the upstream's response to its own return value.

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

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

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

f /</ g replaces all requests in f with g.

respond :: Monad m => a -> p x' x a' a m a'

respond with an output for downstream and bind downstream's next request

respond b satisfies a downstream request by supplying the value b respond blocks until downstream requests a new value and binds the argument from the next request as its return value.

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

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

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

f \<\ g replaces all responds in g with f.

Instances

Interact Proxy

Methods

request :: Monad m => a' -> Proxy a' a x' x m a

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

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

respond :: Monad m => a -> Proxy x' x a' a m a'

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

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

Interact p => Interact (IdentityP p)

Methods

request :: Monad m => a' -> IdentityP p a' a x' x m a

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

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

respond :: Monad m => a -> IdentityP p x' x a' a m a'

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

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

Interact p => Interact (ReaderP i p)

Methods

request :: Monad m => a' -> ReaderP i p a' a x' x m a

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

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

respond :: Monad m => a -> ReaderP i p x' x a' a m a'

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

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