Representions of request data that can be used in routing

A segment of a parser over strings s, which may be a fixed string (usually created through IsString), only accepting a single fixed value, or a dynamic parameter (created through Parameterized), which encapsulates a Parameter type.

A concrete, untyped representation of a parsed Placeholder value, distinguishing fixed components from parameters but abstracting over the parsed type.

A parser/reverse-router isomorphism between sequences of strings (represented as [s]) and a value a. These can be constructed using:

• fromString s (or simply s with OverloadedStrings), which matches a single literal component.
• parameter (or param (undefined :: T) for an explicit type), which matches a place-holder component for a Parameter type.

Sequence values can then be composed using Monoidal and MonoidalAlt.

A URL path parser/generator. These should typically be constructed using the IsString and Parameterized instances. Note that the individual components are decoded path segments, so a literal slash in a component (e.g., as produced with fromString) will match "%2F". Example:

"get" *< parameter >*< "value" *< parameter :: Path (String, Int)

matches (or generates) /get/$x/value/$y for any string $x and any int $y and returns those values.

Remove double- and trailing-slashes (i.e., empty path segments).

Render a Path as instantiated by a value to a list of placeholder values.

Render a Path as instantiated by a value to a list of string segments.

Build a Path as applied to a value into a bytestring Builder by encoding the segments with urlEncodePath and joining them with "/".

A hostname matcher. These should typically be constructed using the IsString and Parameterized instances. This matches hostnames in reverse order (from TLD down), but the Monoidal instance and splitHost automatically deal with this for you. Example:

parameter >* "domain" >* "com" :: Host String

matches (or generates) *.domain.com and returns the * component.

Split (and reverse) a domainname on "." for use with Host.

Reverse and join a hostname with ".".

Instantiate a host with a value and render it as a domainname.

Any types that represent an HTTP method.

A map from query variables to values, based on SimpleQuery.

A blank/unknown request; effectively the default value

A term, qualifier, or component of a route, each specifying one filterattributeparser/generator for a request.

A Monoidal collection of routing predicates. For example:

routeHost ("www" >* "domain.com") *< routePath ("object" *< parameter) :: Route Int

By default, route predicates are matched in the order they are specified, so each test is done only if all preceding tests succeed. However, in most cases routing rules should be tested in a specific order in order to produce sensible errors (e.g., a 405 error that offers available methods should only apply to other routes with the same path). This re-orders the predicates in a route in order of the constructors in RoutePredicate (i.e., host, secure, path, method, ...), allowing you to construct your routes in any order but still produce sensible matching behavior. Alternatively, since there are cases you may watch to match in a different order (e.g., for routePriority), you can specify your routes in specific order and avoid this function (which would also be more efficient). Note that there are some "de-normalized" cases that this will not correct, such as having duplicate routeMethod specifications (in which case all must match, but each is done independently).

Fold over the predicates in an instatiated route.

Given an instantiation of a Route with its value, add the relevant reverse-route information to a Request.

Apply requestRoute' to blankRequest.