Servant.Server.Internal.RoutingApplication

Documentation

type RoutingApplication m

Arguments

 = Request

the request, the field pathInfo may be modified by url routing

-> (RouteResult Response -> m Response)

-> m Response

data RouteResult a

The result of matching against a path in the route tree.

Constructors

Fail ServantErr

Keep trying other paths. The ServantErr should only be 404, 405 or 406.

FailFatal !ServantErr

Don't try other paths.

Route !a

Instances

Functor RouteResult

Methods

fmap :: (a -> b) -> RouteResult a -> RouteResult b

(<$) :: a -> RouteResult b -> RouteResult a

Eq a => Eq (RouteResult a)

Methods

(==) :: RouteResult a -> RouteResult a -> Bool

(/=) :: RouteResult a -> RouteResult a -> Bool

Read a => Read (RouteResult a)

Methods

readsPrec :: Int -> ReadS (RouteResult a)

readList :: ReadS [RouteResult a]

readPrec :: ReadPrec (RouteResult a)

readListPrec :: ReadPrec [RouteResult a]

Show a => Show (RouteResult a)

Methods

showsPrec :: Int -> RouteResult a -> ShowS

show :: RouteResult a -> String

showList :: [RouteResult a] -> ShowS

toApplication :: forall m. MonadSnap m => RoutingApplication m -> Application m

responseLBS :: Status -> [(CI ByteString, ByteString)] -> ByteString -> Response

runAction :: MonadSnap m => Delayed m env (m a) -> env -> Request -> (RouteResult Response -> m r) -> (a -> RouteResult Response) -> m r

data Delayed m env c where

Constructors

Delayed :: {..} -> Delayed m env c

Fields

• capturesD :: env -> DelayedM m captures
• methodD :: DelayedM m ()
• authD :: DelayedM m auth
• bodyD :: DelayedM m body
• serverD :: captures -> auth -> body -> Request -> RouteResult c

Instances

Functor (Delayed m env)

Methods

fmap :: (a -> b) -> Delayed m env a -> Delayed m env b

(<$) :: a -> Delayed m env b -> Delayed m env a

newtype DelayedM m a

Constructors

DelayedM

Fields

• runDelayedM :: Request -> m (RouteResult a)

Instances

MonadTrans DelayedM

Methods

lift :: Monad m => m a -> DelayedM m a

Monad m => Monad (DelayedM m)

Methods

(>>=) :: DelayedM m a -> (a -> DelayedM m b) -> DelayedM m b

(>>) :: DelayedM m a -> DelayedM m b -> DelayedM m b

return :: a -> DelayedM m a

fail :: String -> DelayedM m a

Monad m => Functor (DelayedM m)

Methods

fmap :: (a -> b) -> DelayedM m a -> DelayedM m b

(<$) :: a -> DelayedM m b -> DelayedM m a

Monad m => Applicative (DelayedM m)

Methods

pure :: a -> DelayedM m a

(<*>) :: DelayedM m (a -> b) -> DelayedM m a -> DelayedM m b

liftA2 :: (a -> b -> c) -> DelayedM m a -> DelayedM m b -> DelayedM m c

(*>) :: DelayedM m a -> DelayedM m b -> DelayedM m b

(<*) :: DelayedM m a -> DelayedM m b -> DelayedM m a

MonadIO m => MonadIO (DelayedM m)

Methods

liftIO :: IO a -> DelayedM m a

(Monad m, MonadSnap m) => Alternative (DelayedM m)

Methods

empty :: DelayedM m a

(<|>) :: DelayedM m a -> DelayedM m a -> DelayedM m a

some :: DelayedM m a -> DelayedM m [a]

many :: DelayedM m a -> DelayedM m [a]

emptyDelayed :: Monad m => Proxy (m :: * -> *) -> RouteResult a -> Delayed m env a

A Delayed without any stored checks.

delayedFail :: Monad m => ServantErr -> DelayedM m a

Fail with the option to recover.

delayedFailFatal :: Monad m => ServantErr -> DelayedM m a

Fail fatally, i.e., without any option to recover.

withRequest :: (Request -> DelayedM m a) -> DelayedM m a

Gain access to the incoming request.

addCapture :: forall env a b captured m. Monad m => Delayed m env (a -> b) -> (captured -> DelayedM m a) -> Delayed m (captured, env) b

Add a capture to the end of the capture block.

addMethodCheck :: Monad m => Delayed m env a -> DelayedM m () -> Delayed m env a

Add a method check to the end of the method block.

addAuthCheck :: Monad m => Delayed m env (a -> b) -> DelayedM m a -> Delayed m env b

Add an auth check to the end of the auth block.

addBodyCheck :: Monad m => Delayed m env (a -> b) -> DelayedM m a -> Delayed m env b

Add a body check to the end of the body block.

addAcceptCheck :: Monad m => Delayed m env a -> DelayedM m () -> Delayed m env a

Add an accept header check to the beginning of the body block. There is a tradeoff here. In principle, we'd like to take a bad body (400) response take precedence over a failed accept check (406). BUT to allow streaming the body, we cannot run the body check and then still backtrack. We therefore do the accept check before the body check, when we can still backtrack. There are other solutions to this, but they'd be more complicated (such as delaying the body check further so that it can still be run in a situation where we'd otherwise report 406).

passToServer :: Delayed m env (a -> b) -> (Request -> a) -> Delayed m env b

Many combinators extract information that is passed to the handler without the possibility of failure. In such a case, passToServer can be used.

runDelayed :: Monad m => Delayed m env a -> env -> Request -> m (RouteResult a)

Run a delayed server. Performs all scheduled operations in order, and passes the results from the capture and body blocks on to the actual handler.

This should only be called once per request; otherwise the guarantees about effect and HTTP error ordering break down.