Web.Respond.Monad

you build your api using this stuff.

the monad interface

class (Functor m, MonadIO m) => MonadRespond m where

this class is the api for building your handler.

Methods

respond :: Response -> m ResponseReceived

perform the WAI application respond action (after converting the value to a response)

getRequest :: m Request

get out the request.

getHandlers :: m FailureHandlers

get the FailureHandlers.

withHandlers :: (FailureHandlers -> FailureHandlers) -> m a -> m a

run an inner action that will see an updates set of error handlers. this is useful when you know that inner actions will need to do resource cleanup or something.

getPath :: m PathConsumer

get the path as it's been consumed so far.

withPath :: (PathConsumer -> PathConsumer) -> m a -> m a

run the inner action with an updated path state.

Instances

MonadRespond m => MonadRespond (MaybeT m)

(Functor m, MonadIO m) => MonadRespond (RespondT m)

MonadRespond m => MonadRespond (ExceptT e m)

an implementation

data RespondT m a

RespondT is a monad transformer that provides an implementation of MonadRespond. you build your application using this.

Instances

MonadTrans RespondT

MonadTransControl RespondT

MonadBaseControl b m => MonadBaseControl b (RespondT m)

MonadBase b m => MonadBase b (RespondT m)

Monad m => Monad (RespondT m)

Functor m => Functor (RespondT m)

Applicative m => Applicative (RespondT m)

MonadThrow m => MonadThrow (RespondT m)

MonadCatch m => MonadCatch (RespondT m)

MonadLogger m => MonadLogger (RespondT m)

MonadIO m => MonadIO (RespondT m)

(Functor m, MonadIO m) => MonadRespond (RespondT m)

data StT RespondT = StRespond {

• unStRespond :: StT (ReaderT RespondData) a

}

data StM (RespondT m) = StMT {

• unStMT :: ComposeSt RespondT m a

}

runRespondT :: RespondT m a -> FailureHandlers -> Request -> Responder -> m a

run the RespondT action with failure handlers and request information.

mapRespondT :: (m a -> n b) -> RespondT m a -> RespondT n b

handling errors

data FailureHandlers

record containing responders that request matching tools can use when failures occur.

Constructors

FailureHandlers

Fields

_unsupportedMethod :: MonadRespond m => [StdMethod] -> Method -> m ResponseReceived

what to do if the request method is not supported

_unmatchedPath :: MonadRespond m => m ResponseReceived

what to do if the request path has no matches

_bodyParseFailed :: (MonadRespond m, ReportableError e) => e -> m ResponseReceived

what to do if the body failed to parse

_authFailed :: (MonadRespond m, ReportableError e) => e -> m ResponseReceived

what to do when authentication fails

_accessDenied :: (MonadRespond m, ReportableError e) => e -> m ResponseReceived

what to do when authorization fails

_caughtException :: (MonadRespond m, ReportableError e) => e -> m ResponseReceived

what to do when an exception has been caught

_unacceptableResponse :: MonadRespond m => m ResponseReceived

what to do when no media type is acceptable

Getters for each handler

unsupportedMethod :: forall m. MonadRespond m => Getter FailureHandlers ([StdMethod] -> Method -> m ResponseReceived)

unmatchedPath :: forall m. MonadRespond m => Getter FailureHandlers (m ResponseReceived)

bodyParseFailed :: forall e m. (MonadRespond m, ReportableError e) => Getter FailureHandlers (e -> m ResponseReceived)

authFailed :: forall e m. (MonadRespond m, ReportableError e) => Getter FailureHandlers (e -> m ResponseReceived)

accessDenied :: forall e m. (MonadRespond m, ReportableError e) => Getter FailureHandlers (e -> m ResponseReceived)

caughtException :: forall e m. (MonadRespond m, ReportableError e) => Getter FailureHandlers (e -> m ResponseReceived)

unacceptableResponse :: forall m. MonadRespond m => Getter FailureHandlers (m ResponseReceived)