Control.Monad.Request.Lazy

Computation type:

Compuations that send requests and handle responses

Binding strategy:

Response callbacks are composed with the binding function

Useful for:

Implementation-agnostic requests (i.e. making real requests versus mocking), adding middlewares.

Example type:

Request String String a

The Request monad

MonadRequest

class Monad m => MonadRequest r r' m | m -> r r' where

This type class generalizes monadic requests.

Parameters:

• r - The type of request
• r' - The type of response
• m - The monad through which the requests are sent

Methods

send :: r -> m r'

Given a request of type r, perform an action in m whose result is r'.

Instances

MonadRequest r r' m => MonadRequest r r' (MaybeT m)

MonadRequest r r' m => MonadRequest r r' (ListT m)

MonadRequest r r' m => MonadRequest r r' (IdentityT m)

(Monoid w, MonadRequest r r' m) => MonadRequest r r' (WriterT w m)

(Monoid w, MonadRequest r r' m) => MonadRequest r r' (WriterT w m)

MonadRequest r r' m => MonadRequest r r' (StateT x m)

MonadRequest r r' m => MonadRequest r r' (StateT x m)

MonadRequest r r' m => MonadRequest r r' (ReaderT x m)

MonadRequest r r' m => MonadRequest r r' (ExceptT e m)

(Error e, MonadRequest r r' m) => MonadRequest r r' (ErrorT e m)

MonadRequest r r' m => MonadRequest r r' (ContT x m)

Monad m => MonadRequest r r' (RequestT r r' m)

(Monoid w, MonadRequest r r' m) => MonadRequest r r' (RWST x w s m)

(Monoid w, MonadRequest r r' m) => MonadRequest r r' (RWST x w s m)

Request

type Request r r' = RequestT r r' Identity

A Request monad, parameterized by the request type, r, and response type, r'. together.

request

Arguments

:: r

The request

-> (r' -> a)

The response callback

-> Request r r' a

The resulting computation

Turn a request and response callback into a monadic computation.

runRequest

Arguments

:: Request r r' a

The computation to run

-> (r -> r')

A function that turns requests into responses

-> a

The final result of the computation

Evaluate a Request r r' a action.

mapRequest

Arguments

:: (x -> r)

The middleware function

-> Request x r' a

The computation which sends x

-> Request r r' a

The computation which sends r

Given a x -> r, transform a computation that sends requests of type x into one that sends requests of type r.

mapResponse

Arguments

:: (r' -> x)

The middleware function

-> Request r x a

The computation which handles x

-> Request r r' a

The computation which handles r'

Given a mapping from r' -> x, transform a computation handles responses of type x to one that handles responses of type r'.

RequestT

data RequestT r r' m a

A request monad, parameterized by the request type, r, response type, r', and inner monad, m.

Instances

(Monoid w, MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (RequestT r r' m)

Monad m => MonadRequest r r' (RequestT r r' m)

MonadError e m => MonadError e (RequestT r r' m)

MonadReader x m => MonadReader x (RequestT r r' m)

MonadState s m => MonadState s (RequestT r r' m)

(Monoid w, MonadWriter w m) => MonadWriter w (RequestT r r' m)

MonadTrans (RequestT r r')

Alternative m => Alternative (RequestT r r' m)

Monad m => Monad (RequestT r r' m)

Functor m => Functor (RequestT r r' m)

MonadPlus m => MonadPlus (RequestT r r' m)

Applicative m => Applicative (RequestT r r' m)

MonadIO m => MonadIO (RequestT r r' m)

requestT

Arguments

:: Monad m

=> r

The request

-> (r' -> m a)

The response callback

-> RequestT r r' m a

The resulting computation

This function takes a request and monadic response handler to produce a RequestT r r' m a.

runRequestT

Arguments

:: Monad m

=> RequestT r r' m a

The computation to run

-> (r -> m r')

The request function

-> m a

The resulting computation

Given a RequestT r r' m a and a mapping from requests to responses, return a monadic computation which produces a.

mapRequestT

Arguments

:: Monad m

=> (x -> m r)

The middleware function

-> RequestT x r' m a

The x-requesting computation

-> RequestT r r' m a

The r-requesting computation

Turn a computation that requests x into a computation that requests r.

mapResponseT

Arguments

:: Monad m

=> (r' -> m x)

The middleware function

-> RequestT r x m a

The x-handling computation

-> RequestT r r' m a

The r'-handling computation

Turn a computation that handles x into a computation that handles r'.