Previously, ServerT raw m ~ Application. Seems reasonable, but has the
unfortunate consequence of making Enter useless for Raw routes.
Attempting to solve the Enter class constraint for a Raw route will run
up to IO ResponseReceived, the tail end of the Wai Application type,
in practical use ultimately demanding something along the lines of:
Enter (IO ResponseReceived)
(yourMonad :~> EitherT ServantErr IO)
(IO ResponseReceived)
There's no need to use Enter on a Raw route anyway, I know, but with
this change, the programmer can treat Raw routes and non-Raw routes
uniformly with respect to Enter.
This introduces a `Delayed` type in `RoutingApplication.hs` that
contains a handler together with delayed checks. There are several
blocks of delayed checks, so that we can ultimately execute them in the
order we desire.
The process is documented in more detail in `RoutingApplication.hs`.
tighter version bounds for network
cleanup
document the new combinators
servant-server: add some tests for HttpVersion, IsSecure, RemoteHost and Vault
update changelogs
address Julian's feedback
remove vault test in servant-server
servant-server tests: -Werror friendly
The main `Server.Internal` module was getting a bit large for my taste.
It now contains just the instances. All the administrative utilities
are in their own dedicated modules.
Instead of directly interpreting a server as a `RoutingApplication`,
this change introduces the concept of a `Router`, which is a datatype
with several constructors.
In particular, the type of the `route` function changes from
route :: Proxy layout -> Server layout -> RoutingApplication
to
route :: Proxy layout -> IO (RouteResult (Server layout)) -> Router
Most important in practice is the case of the `StaticRouter` constructor
in `Router`. For choices between statically known paths, we can now use
a lookup table to dispatch requests rather than trying each request
individually.
This brings down routing complexity of a common case from
O(n) to O(log n).
Another important change is that the handler that is passed down by
`route` is no longer of type `Server layout`, but of type
`IO (RouteResult (Server layout))`. This means that API constructs
can "delay" checks and failure. For example, `ReqBody` does not have
to fetch the request body and feed it to the handler immediately; it
can instead record these actions in the handler that is passed down.
The code will only be executed at a leaf / endpoint of the API.
This is desired behaviour: We prefer to save work by doing all matching
on static path components first. Furthermore, we get better error codes
by doing so.
