This module provides four classes and some related functions
which provide ServerPartT
with much of its webcentric behavior.

ServerMonad
provides access to the HTTPRequest

FilterMonad
provides the ability to apply filters and transformations to aResponse

WebMonad
provides a way to escape a computation early and return aResponse

HasRqData
which provides access to the decoded QUERY_STRING and request body/form data
 data ServerPartT m a
 type ServerPart a = ServerPartT IO a
 class (ServerMonad m, WebMonad Response m, FilterMonad Response m, MonadIO m, MonadPlus m, HasRqData m, Monad m, Functor m) => Happstack m
 class Monad m => ServerMonad m where
 mapServerPartT :: (UnWebT m a > UnWebT n b) > ServerPartT m a > ServerPartT n b
 mapServerPartT' :: (Request > UnWebT m a > UnWebT n b) > ServerPartT m a > ServerPartT n b
 type UnWebT m a = m (Maybe (Either Response a, FilterFun Response))
 filterFun :: (a > a) > FilterFun a
 class Monad m => FilterMonad a m  m > a where
 setFilter :: (a > a) > m ()
 composeFilter :: (a > a) > m ()
 getFilter :: m b > m (b, a > a)
 ignoreFilters :: FilterMonad a m => m ()
 addHeaderM :: FilterMonad Response m => String > String > m ()
 getHeaderM :: ServerMonad m => String > m (Maybe ByteString)
 setHeaderM :: FilterMonad Response m => String > String > m ()
 class Monad m => WebMonad a m  m > a where
 finishWith :: a > m b
 escape :: (WebMonad a m, FilterMonad a m) => m a > m b
 escape' :: (WebMonad a m, FilterMonad a m) => a > m b
 require :: (MonadIO m, MonadPlus m) => IO (Maybe a) > (a > m r) > m r
 requireM :: (MonadTrans t, Monad m, MonadPlus (t m)) => m (Maybe a) > (a > t m r) > t m r
ServerPartT
data ServerPartT m a Source
ServerPartT
is a rich, featureful monad for web development.
see also: simpleHTTP
, ServerMonad
, FilterMonad
, WebMonad
, and HasRqData
MonadTrans ServerPartT  
(Monad m, MonadError e m) => MonadError e (ServerPartT m)  
(Monad m, MonadReader r m) => MonadReader r (ServerPartT m)  
(Monad m, MonadState s m) => MonadState s (ServerPartT m)  
(Monad m, MonadWriter w m) => MonadWriter w (ServerPartT m)  
Monad m => WebMonad Response (ServerPartT m)  
Monad m => FilterMonad Response (ServerPartT m)  
Monad m => Monad (ServerPartT m)  
Functor m => Functor (ServerPartT m)  
Monad m => MonadPlus (ServerPartT m)  
(Monad m, Functor m) => Applicative (ServerPartT m)  
(Functor m, MonadPlus m) => Alternative (ServerPartT m)  
MonadIO m => MonadIO (ServerPartT m)  
Monad m => ServerMonad (ServerPartT m)  
MonadIO m => HasRqData (ServerPartT m)  
(Functor m, Monad m, MonadPlus m, MonadIO m) => Happstack (ServerPartT m)  
Monad m => Monoid (ServerPartT m a) 
type ServerPart a = ServerPartT IO aSource
An alias for ServerPartT
IO
Happstack class
class (ServerMonad m, WebMonad Response m, FilterMonad Response m, MonadIO m, MonadPlus m, HasRqData m, Monad m, Functor m) => Happstack m Source
A class alias for all the classes a standard server monad (such as ServerPartT
) is expected to have instances for. This allows you to keep your type signatures shorter and easier to understand.
ServerMonad
class Monad m => ServerMonad m whereSource
The ServerMonad
class provides methods for reading or locally
modifying the Request
. It is essentially a specialized version of
the MonadReader
class. Providing the unique names, askRq
and
localRq
makes it easier to use ServerPartT
and ReaderT
together.
Monad m => ServerMonad (ServerPartT m)  
(Error e, ServerMonad m) => ServerMonad (ErrorT e m) 
mapServerPartT :: (UnWebT m a > UnWebT n b) > ServerPartT m a > ServerPartT n bSource
Apply a function to transform the inner monad of
.
ServerPartT
m
Often used when transforming a monad with ServerPartT
, since
simpleHTTP
requires a
. Refer to ServerPartT
IO
aUnWebT
for an explanation of the structure of the monad.
Here is an example. Suppose you want to embed an ErrorT
into your
ServerPartT
to enable throwError
and catchError
in your Monad
.
type MyServerPartT e m a = ServerPartT (ErrorT e m) a
Now suppose you want to pass MyServerPartT
into a function that
demands a
(e.g. ServerPartT
IO
asimpleHTTP
). You can
provide the function:
unpackErrorT :: (Monad m, Show e) => UnWebT (ErrorT e m) a > UnWebT m a unpackErrorT et = do eitherV < runErrorT et return $ case eitherV of Left err > Just (Left $ toResponse $ "Catastrophic failure " ++ show err , filterFun $ \r > r{rsCode = 500}) Right x > x
With unpackErrorT
you can now call simpleHTTP
. Just wrap your
ServerPartT
list.
simpleHTTP nullConf $ mapServerPartT unpackErrorT (myPart `catchError` myHandler)
Or alternatively:
simpleHTTP' unpackErrorT nullConf (myPart `catchError` myHandler)
Also see Happstack.Server.Error.spUnwrapErrorT
for a more sophisticated version of this
function.
mapServerPartT' :: (Request > UnWebT m a > UnWebT n b) > ServerPartT m a > ServerPartT n bSource
A variant of mapServerPartT
where the first argument also takes
a Request
. Useful if you want to runServerPartT
on a different
ServerPartT
inside your monad (see spUnwrapErrorT
).
type UnWebT m a = m (Maybe (Either Response a, FilterFun Response))Source
UnWebT
is almost exclusively used with mapServerPartT
. If you
are not using mapServerPartT
then you do not need to wrap your
head around this type. If you are  the type is not as complex as
it first appears.
It is worth discussing the unpacked structure of WebT
a bit as
it's exposed in mapServerPartT
and mapWebT
.
A fully unpacked WebT
has a structure that looks like:
ununWebT $ WebT m a :: m (Maybe (Either Response a, FilterFun Response))
So, ignoring m
, as it is just the containing Monad
, the
outermost layer is a Maybe
. This is Nothing
if mzero
was
called or
if Just
(Either
Response
a, SetAppend
(Endo
Response
))mzero
wasn't called. Inside the Maybe
, there
is a pair. The second element of the pair is our filter function
. FilterFun
Response
is a type
alias for FilterFun
Response
. This is
just a wrapper for a SetAppend
(Dual
(Endo
Response
))
function with a
particular Response
> Response
Monoid
behavior. The value
Append (Dual (Endo f))
Causes f
to be composed with the previous filter.
Set (Dual (Endo f))
Causes f
to not be composed with the previous filter.
Finally, the first element of the pair is either
or Left
Response
.
Right
a
Another way of looking at all these pieces is from the behaviors
they control. The Maybe
controls the mzero
behavior.
comes from the Set
(Endo
f)setFilter
behavior. Likewise,
is from Append
(Endo
f)composeFilter
.
is what you get when you call Left
Response
finishWith
and
is the normal exit.
Right
a
An example case statement looks like:
ex1 webt = do val < ununWebT webt case val of Nothing > Nothing  this is the interior value when mzero was used Just (Left r, f) > Just (Left r, f)  r is the value that was passed into "finishWith"  f is our filter function Just (Right a, f) > Just (Right a, f)  a is our normal monadic value  f is still our filter function
filterFun :: (a > a) > FilterFun aSource
turn a function into a FilterFun
. Primarily used with mapServerPartT
FilterMonad
class Monad m => FilterMonad a m  m > a whereSource
A set of functions for manipulating filters.
ServerPartT
implements FilterMonad
Response
so these methods
are the fundamental ways of manipulating Response
values.
setFilter :: (a > a) > m ()Source
Ignores all previous alterations to your filter
As an example:
do composeFilter f setFilter g return "Hello World"
The
will cause the first setFilter
g
to
be ignored.
composeFilter
f
composeFilter :: (a > a) > m ()Source
Composes your filter function with the existing filter function.
getFilter :: m b > m (b, a > a)Source
Retrieves the filter from the environment.
Monad m => FilterMonad Response (WebT m)  
Monad m => FilterMonad Response (ServerPartT m)  
Monad m => FilterMonad a (FilterT a m) 
ignoreFilters :: FilterMonad a m => m ()Source
addHeaderM :: FilterMonad Response m => String > String > m ()Source
Add headers into the response. This method does not overwrite
any existing header of the same name, hence the name addHeaderM
.
If you want to replace a header use setHeaderM
.
getHeaderM :: ServerMonad m => String > m (Maybe ByteString)Source
Get a header out of the request.
setHeaderM :: FilterMonad Response m => String > String > m ()Source
Set a header into the response. This will replace an existing
header of the same name. Use addHeaderM
if you want to add more
than one header of the same name.
WebMonad
class Monad m => WebMonad a m  m > a whereSource
WebMonad
provides a means to end the current computation
and return a Response
immediately. This provides an
alternate escape route. In particular it has a monadic value
of any type. And unless you call
first your
response filters will be applied normally.
setFilter
id
Extremely useful when you're deep inside a monad and decide
that you want to return a completely different content type,
since it doesn't force you to convert all your return types to
Response
early just to accommodate this.
:: a  value to return (For 
> m b 
escape :: (WebMonad a m, FilterMonad a m) => m a > m bSource
Used to ignore all your filters and immediately end the
computation. A combination of ignoreFilters
and finishWith
.
escape' :: (WebMonad a m, FilterMonad a m) => a > m bSource
An alternate form of escape
that can be easily used within a do
block.