Embed a MiddlewareT into a set of routes via a matching string. You should expect the match to create arity in your handler - the childContent variable. The arity of childContent may grow or shrink, depending on the heterogeneous list created from the list of parsers, regular expressions, or arbitrary predicates in the order written - so something like:

match (p_ "double-parser" double </> o_)
  handler

...then handler must have arity Double ->. If this route was at the top level, then the total arity must be Double -> MiddlewareT m.

Generally, if the routes you are building get grouped by a predicate with matchGroup, then we would need another level of arity before the Double.

Create a handle for the current route - an alias for h -> match o_ h.

Match against any route, as a last resort against all failing matches - use this for a catch-all at some level in their routes, something like a not-found 404 page is useful.

Prepends a common route to an existing set of routes. You should note that doing this with a parser or regular expression will necessitate the existing arity in the handlers before the progam can compile.

Sets the security role and error handler for a set of routes, optionally including its parent route.

Use this function to run your RouterT into a MiddlewareT; making your router executable in WAI. Note that this only responds with content, and doesn't protect your routes with your calls to auth; to protect routes, postcompose this with routeAuth:

route routes . routeAuth routes

Supply a method to decide whether or not to throwM an exception based on the current Request and the layers of auth tokens passed in your router, turn your router into a guard for middlewares, basically.

Extracts only the normal match, matchGroup and matchHere routes.

Extracts only the matchAny responses; something like the greatest-lower-bound.

Find the security tokens / authorization roles affiliated with a request for a set of routes.

Extracts only the security handling logic, and turns it into a guard.

Given a way to draw out a special-purpose trie from our route set, route to the responses based on a furthest-route-reached method, or like a greatest-lower-bound.

Use a custom security token type and an AuthScope to define where and what kind of security should take place.

Designate the scope of security to the set of routes - either only the adjacent routes, or the adjacent and the parent container node (root node if not declared).

The constraints necessary for match.

The constraints necessary for matchGroup.

Container when defining route paths

Constrained to AttoParsec, Regex-Compat and T.Text

The Origin chunk - the equivalent to []

Match against a Literal chunk

Removes file extension from the matchedhttp:/hackage.haskell.orgpackage/nested-routes route

Match against a Parsed chunk, with attoparsec.

Match against a Regular expression chunk, with regex-compat.

Match with a predicate against the url chunk directly.

Prefix a routable path by more predicative lookup data.

The type of "content" builders; using the wai-middleware-verbs and wai-middleware-content-type packages.

Soundness constraint showing that a function's arity can be represented as a type-level list.

The (syntactic) monad for building a router with functions like "Web.Routes.Nested.match". it should have a shape of RouterT (MiddlewareT m) (SecurityToken s) m a when used with "Web.Routes.Nested.route".

The internal data structure built during route declaration.

Run the monad, only getting the built state and throwing away a.

Run the content builder into a middleware that responds when the content is satisfiable (i.e. Accept headers are O.K., etc.)

Given an HTTP Accept header and a content type to base lookups off of, and a map of responses, find a response.

The exact same thing as Network.Wai.responseLBS.

Use this combinator as the last one, as a "catch-all":

myApp = do
  text "foo"
  invalidEncoding myErrorHandler -- handles all except text/plain

Takes an Accept header and returns the other file types handleable, in order of prescedence.

matches a file extension (including it's prefix dot - .html for example) to a known one.

Gets the known file extension from a Request's pathInfo.

Supported file extensions

The monad for our DSL - when using the combinators, our result will be this type:

myListener :: FileExtListenerT base (MiddlewareT m) m ()
myListener = do
  text "Text!"
  json ("Json!" :: T.Text)