happstack-server-6.4.6: Web related tools and services.

Happstack.Server.Routing

Contents

Description

Route an incoming Request to a handler. For more in-depth documentation see this section of the Happstack Crash Course: http://happstack.com/docs/crashcourse/RouteFilters.html

Synopsis

Route by request method

methodM :: (ServerMonad m, MonadPlus m, MatchMethod method) => method -> m ()Source

Guard against the method. This function also guards against *any remaining path segments*. See method for the version that guards only by method.

Example:

 handler :: ServerPart Response
 handler =
     do methodM [GET, HEAD]
        ...

NOTE: This function is largely retained for backwards compatibility. The fact that implicitly calls nullDir is often forgotten and leads to confusion. It is probably better to just use method and call nullDir explicitly.

This function will likely be deprecated in the future.

methodOnly :: (ServerMonad m, MonadPlus m, MatchMethod method) => method -> m ()Source

Guard against the method only (as opposed to methodM).

Example:

 handler :: ServerPart Response
 handler =
     do methodOnly [GET, HEAD]
        ...

methodSP :: (ServerMonad m, MonadPlus m, MatchMethod method) => method -> m b -> m bSource

Guard against the method. Note, this function also guards against any remaining path segments. Similar to methodM but with a different type signature.

Example:

 handler :: ServerPart Response
 handler = methodSP [GET, HEAD] $ subHandler

NOTE: This style of combinator is going to be deprecated in the future. It is better to just use method.

method :: (ServerMonad m, MonadPlus m, MatchMethod method) => method -> m ()Source

Guard against the method only (as opposed to methodM).

Example:

 handler :: ServerPart Response
 handler =
     do methodOnly [GET, HEAD]
        ...

class MatchMethod m whereSource

instances of this class provide a variety of ways to match on the Request method.

Examples

 method GET                  -- match GET
 method [HEAD, GET]          -- match HEAD or GET
 method (not . (==) DELETE)  -- match any method except DELETE
 method ()                   -- match any method

Methods

matchMethod :: m -> Method -> BoolSource

Route by pathInfo

dir :: (ServerMonad m, MonadPlus m) => String -> m a -> m aSource

Pop a path element and run the supplied handler if it matches the given string.

 handler :: ServerPart Response
 handler = dir "foo" $ dir "bar" $ subHandler

The path element can not contain '/'. See also dirs.

dirs :: (ServerMonad m, MonadPlus m) => FilePath -> m a -> m aSource

Guard against a FilePath. Unlike dir the FilePath may contain '/'. If the guard succeeds, the matched elements will be popped from the directory stack.

 dirs "foo/bar" $ ...

See also: dir.

nullDir :: (ServerMonad m, MonadPlus m) => m ()Source

guard which only succeeds if there are no remaining path segments

Often used if you want to explicitly assign a route for /

trailingSlash :: (ServerMonad m, MonadPlus m) => m ()Source

Guard which checks that the Request URI ends in '/'. Useful for distinguishing between foo and foo/

anyPath :: (ServerMonad m, MonadPlus m) => m r -> m rSource

Pop any path element and run the handler.

Succeeds if a path component was popped. Fails is the remaining path was empty.

path :: (FromReqURI a, MonadPlus m, ServerMonad m) => (a -> m b) -> m bSource

Pop a path element and parse it using the fromReqURI in the FromReqURI class.

uriRest :: ServerMonad m => (String -> m a) -> m aSource

Grab the rest of the URL (dirs + query) and passes it to your handler.

Route by host

host :: (ServerMonad m, MonadPlus m) => String -> m a -> m aSource

Guard against the host.

This matches against the host header specified in the incoming Request.

Can be used to support virtual hosting, http://en.wikipedia.org/wiki/Virtual_hosting

see also: withHost

withHost :: (ServerMonad m, MonadPlus m) => (String -> m a) -> m aSource

Lookup the host header in the incoming request and pass it to the handler.

see also: host

Route by (Request -> Bool)

guardRq :: (ServerMonad m, MonadPlus m) => (Request -> Bool) -> m ()Source

Guard using an arbitrary function on the Request.