-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Web related tools and services.
--   
--   Web framework
@package happstack-server
@version 0.5.0.4

module Happstack.Server.MinHaXML
type StyleURL = String
data StyleSheet
NoStyle :: StyleSheet
CSS :: StyleURL -> StyleSheet
styleURL :: StyleSheet -> StyleURL
XSL :: StyleURL -> StyleSheet
styleURL :: StyleSheet -> StyleURL
hasStyleURL :: StyleSheet -> Bool
type Element = Element
isCSS :: StyleSheet -> Bool
isXSL :: StyleSheet -> Bool
t :: Name -> [(Name, String)] -> CharData -> Element
l :: Name -> [(Name, String)] -> [Element] -> Element
e :: Name -> [(Name, String)] -> Element
(</<) :: Name -> [(Name, String)] -> [Element] -> Element
(<>) :: Name -> [(Name, String)] -> CharData -> Element
xmlElem :: (t -> [Content]) -> Name -> [(Name, String)] -> t -> Element
textElem :: Name -> [(Name, String)] -> CharData -> Element
emptyElem :: Name -> [(Name, String)] -> Element
listElem :: Name -> [(Name, String)] -> [Element] -> Element
cdataElem :: CharData -> Content
simpleDocOld :: StyleSheet -> Element -> String
simpleDoc :: StyleSheet -> Element -> String
simpleDoc' :: StyleSheet -> Element -> String
xmlEscaper :: XmlEscaper
xmlStdEscape :: Element -> Element
verbim :: Verbatim a => a -> String
simpleProlog :: StyleSheet -> Prolog
nonEmpty :: Name -> String -> Maybe Element
getRoot :: Document -> Element
data XML a
XML :: StyleSheet -> a -> XML a
class ToElement x
toElement :: ToElement x => x -> Element
wrapElem :: ToElement x => Name -> x -> Element
elF :: ToElement b => Name -> (a -> b) -> a -> Element
attrF :: t1 -> (t -> String) -> t -> (t1, String)
attrFS :: Show a => t1 -> (t -> a) -> t -> (t1, String)
attrFMb :: (a -> String) -> String -> (a1 -> Maybe a) -> a1 -> (String, String)
quoteEsc :: String -> String
recToEl :: Name -> [a -> (String, String)] -> [a -> Element] -> a -> Element
listToEl :: ToElement a => Name -> [(Name, String)] -> [a] -> Element
toAttrs :: t -> [(t1, t -> t2)] -> [(t1, t2)]
newtype ElString
ElString :: String -> ElString
elString :: ElString -> String
instance [overlap ok] Read StyleSheet
instance [overlap ok] Show StyleSheet
instance [overlap ok] Eq ElString
instance [overlap ok] Ord ElString
instance [overlap ok] Read ElString
instance [overlap ok] Show ElString
instance [overlap ok] Xml a => ToElement a
instance [overlap ok] ToElement Double
instance [overlap ok] ToElement Float
instance [overlap ok] ToElement Integer
instance [overlap ok] ToElement Int
instance [overlap ok] ToElement CalendarTime
instance [overlap ok] ToElement Element
instance [overlap ok] ToElement String
instance [overlap ok] ToElement x => ToElement (Maybe x)

module Happstack.Server.SURI

-- | Retrieves the path component from the URI
path :: SURI -> String

-- | Retrieves the query component from the URI
query :: SURI -> String

-- | Retrieves the scheme component from the URI
scheme :: SURI -> String

-- | Modifies the scheme component of the URI using the provided function
u_scheme :: (String -> String) -> SURI -> SURI

-- | Modifies the path component of the URI using the provided function
u_path :: (String -> String) -> SURI -> SURI

-- | Sets the scheme component of the URI
a_scheme :: String -> SURI -> SURI

-- | Sets the path component of the URI
a_path :: String -> SURI -> SURI
unEscape :: String -> String
escape :: String -> String

-- | Returns true if the URI is absolute
isAbs :: SURI -> Bool
newtype SURI
SURI :: URI -> SURI
suri :: SURI -> URI

-- | Render should be used for prettyprinting URIs.
render :: ToSURI a => a -> String

-- | Parses a URI from a String. Returns Nothing on failure.
parse :: String -> Maybe SURI

-- | Convenience class for converting data types to URIs
class ToSURI x
toSURI :: ToSURI x => x -> SURI
class FromPath x
fromPath :: FromPath x => String -> x
instance [overlap ok] Typeable SURI
instance [overlap ok] Eq SURI
instance [overlap ok] Data SURI
instance [overlap ok] ToSURI String
instance [overlap ok] ToSURI URI
instance [overlap ok] ToSURI SURI
instance [overlap ok] Ord SURI
instance [overlap ok] Read SURI
instance [overlap ok] Show SURI

module Happstack.Server.Cookie
data Cookie
Cookie :: String -> String -> String -> String -> String -> Bool -> Cookie
cookieVersion :: Cookie -> String
cookiePath :: Cookie -> String
cookieDomain :: Cookie -> String
cookieName :: Cookie -> String
cookieValue :: Cookie -> String
secure :: Cookie -> Bool

-- | Creates a cookie with a default version of 1 and path of <a>/</a>
mkCookie :: String -> String -> Cookie

-- | Set a Cookie in the Result. The values are escaped as per RFC 2109,
--   but some browsers may have buggy support for cookies containing e.g.
--   <tt>'"'</tt> or <tt>' '</tt>.
--   
--   Also, it seems that chrome, safari, and other webkit browsers do not
--   like cookies which have double quotes around the domain and
--   reject/ignore the cookie. So, we no longer quote the domain.
mkCookieHeader :: Seconds -> Cookie -> String

-- | Get all cookies from the HTTP request. The cookies are ordered per RFC
--   from the most specific to the least specific. Multiple cookies with
--   the same name are allowed to exist.
getCookies :: Monad m => ByteString -> m [Cookie]

-- | Get the most specific cookie with the given name. Fails if there is no
--   such cookie or if the browser did not escape cookies in a proper
--   fashion. Browser support for escaping cookies properly is very
--   diverse.
getCookie :: Monad m => String -> ByteString -> m Cookie
getCookies' :: Monad m => ByteString -> m (Either String [Cookie])
getCookie' :: Monad m => String -> ByteString -> m (Either String Cookie)

-- | Not an supported api. Takes a cookie header and returns either a
--   String error message or an array of parsed cookies
parseCookies :: String -> Either String [Cookie]

-- | not a supported api. A parser for RFC 2109 cookies
cookiesParser :: GenParser Char st [Cookie]
instance [overlap ok] Typeable Cookie
instance [overlap ok] Show Cookie
instance [overlap ok] Eq Cookie
instance [overlap ok] Read Cookie
instance [overlap ok] Data Cookie

module Happstack.Server.HTTP.Types
data Request
Request :: Method -> [String] -> String -> String -> [(String, Input)] -> [(String, Cookie)] -> Version -> Headers -> RqBody -> Host -> Request
rqMethod :: Request -> Method
rqPaths :: Request -> [String]
rqUri :: Request -> String
rqQuery :: Request -> String
rqInputs :: Request -> [(String, Input)]
rqCookies :: Request -> [(String, Cookie)]
rqVersion :: Request -> Version
rqHeaders :: Request -> Headers
rqBody :: Request -> RqBody
rqPeer :: Request -> Host
data Response
Response :: Int -> Headers -> RsFlags -> ByteString -> Maybe (Response -> IO Response) -> Response
rsCode :: Response -> Int
rsHeaders :: Response -> Headers
rsFlags :: Response -> RsFlags
rsBody :: Response -> ByteString
rsValidator :: Response -> Maybe (Response -> IO Response)
SendFile :: Int -> Headers -> RsFlags -> Maybe (Response -> IO Response) -> FilePath -> Integer -> Integer -> Response
rsCode :: Response -> Int
rsHeaders :: Response -> Headers
rsFlags :: Response -> RsFlags
rsValidator :: Response -> Maybe (Response -> IO Response)
sfFilePath :: Response -> FilePath
sfOffset :: Response -> Integer
sfCount :: Response -> Integer
newtype RqBody
Body :: ByteString -> RqBody
data Input
Input :: ByteString -> Maybe String -> ContentType -> Input
inputValue :: Input -> ByteString
inputFilename :: Input -> Maybe String
inputContentType :: Input -> ContentType
data HeaderPair
HeaderPair :: ByteString -> [ByteString] -> HeaderPair
hName :: HeaderPair -> ByteString
hValue :: HeaderPair -> [ByteString]

-- | Converts a Request into a String representing the corresponding URL
rqURL :: Request -> String

-- | Takes a list of (key,val) pairs and converts it into Headers. The keys
--   will be converted to lowercase
mkHeaders :: [(String, String)] -> Headers

-- | Lookup header value. Key is case-insensitive.
getHeader :: HasHeaders r => String -> r -> Maybe ByteString

-- | Lookup header value. Key is a case-insensitive bytestring.
getHeaderBS :: HasHeaders r => ByteString -> r -> Maybe ByteString

-- | Lookup header value with a case-sensitive key. The key must be
--   lowercase.
getHeaderUnsafe :: HasHeaders r => ByteString -> r -> Maybe ByteString

-- | Returns True if the associated key is found in the Headers. The lookup
--   is case insensitive.
hasHeader :: HasHeaders r => String -> r -> Bool

-- | Acts as <a>hasHeader</a> with ByteStrings
hasHeaderBS :: HasHeaders r => ByteString -> r -> Bool

-- | Acts as <a>hasHeaderBS</a> but the key is case sensitive. It should be
--   in lowercase.
hasHeaderUnsafe :: HasHeaders r => ByteString -> r -> Bool

-- | Associates the key/value pair in the headers. Forces the key to be
--   lowercase.
setHeader :: HasHeaders r => String -> String -> r -> r

-- | Acts as <a>setHeader</a> but with ByteStrings.
setHeaderBS :: HasHeaders r => ByteString -> ByteString -> r -> r

-- | Sets the key to the HeaderPair. This is the only way to associate a
--   key with multiple values via the setHeader* functions. Does not force
--   the key to be in lowercase or guarantee that the given key and the key
--   in the HeaderPair will match.
setHeaderUnsafe :: HasHeaders r => ByteString -> HeaderPair -> r -> r

-- | Add a key/value pair to the header. If the key already has a value
--   associated with it, then the value will be appended. Forces the key to
--   be lowercase.
addHeader :: HasHeaders r => String -> String -> r -> r

-- | Acts as addHeader except for ByteStrings
addHeaderBS :: HasHeaders r => ByteString -> ByteString -> r -> r

-- | Add a key/value pair to the header using the underlying HeaderPair
--   data type. Does not force the key to be in lowercase or guarantee that
--   the given key and the key in the HeaderPair will match.
addHeaderUnsafe :: HasHeaders r => ByteString -> HeaderPair -> r -> r

-- | Sets the Response status code to the provided Int and lifts the
--   computation into a Monad.
setRsCode :: Monad m => Int -> Response -> m Response

-- | HTTP configuration
data Conf
Conf :: Int -> Maybe (Response -> IO Response) -> Conf

-- | Port for the server to listen on.
port :: Conf -> Int
validator :: Conf -> Maybe (Response -> IO Response)

-- | Default configuration contains no validator and the port is set to
--   8000
nullConf :: Conf

-- | Creates a Response with the given Int as the status code and the
--   provided String as the body of the Response
result :: Int -> String -> Response

-- | Acts as <a>result</a> but works with ByteStrings directly.
resultBS :: Int -> ByteString -> Response

-- | Sets the Response's status code to the given Int and redirects to the
--   given URI
redirect :: ToSURI s => Int -> s -> Response -> Response

-- | Result flags
data RsFlags
RsFlags :: Bool -> RsFlags

-- | whether a content-length header will be added to the result.
rsfContentLength :: RsFlags -> Bool

-- | Default RsFlags that will include the content-length header
nullRsFlags :: RsFlags

-- | Don't display a Content-Lenght field for the <tt>Result</tt>.
noContentLength :: Response -> Response

-- | HTTP version
data Version
Version :: Int -> Int -> Version

-- | HTTP request method
data Method
GET :: Method
HEAD :: Method
POST :: Method
PUT :: Method
DELETE :: Method
TRACE :: Method
OPTIONS :: Method
CONNECT :: Method

-- | Combined headers.
type Headers = Map ByteString HeaderPair

-- | Should the connection be used for further messages after this. |
--   isHTTP1_0 &amp;&amp; hasKeepAlive || isHTTP1_1 &amp;&amp;
--   hasNotConnectionClose
continueHTTP :: Request -> Response -> Bool
type Host = (String, Int)

-- | A MIME media type value. The <a>Show</a> instance is derived
--   automatically. Use <a>showContentType</a> to obtain the standard
--   string representation. See <a>http://www.ietf.org/rfc/rfc2046.txt</a>
--   for more information about MIME media types.
data ContentType
ContentType :: String -> String -> [(String, String)] -> ContentType

-- | The top-level media type, the general type of the data. Common
--   examples are "text", "image", "audio", "video", "multipart", and
--   "application".
ctType :: ContentType -> String

-- | The media subtype, the specific data format. Examples include "plain",
--   "html", "jpeg", "form-data", etc.
ctSubtype :: ContentType -> String

-- | Media type parameters. On common example is the charset parameter for
--   the "text" top-level type, e.g. <tt>("charset","ISO-8859-1")</tt>.
ctParameters :: ContentType -> [(String, String)]
instance [overlap ok] Typeable RsFlags
instance [overlap ok] Typeable Input
instance [overlap ok] Typeable Response
instance [overlap ok] Typeable RqBody
instance [overlap ok] Typeable Request
instance [overlap ok] Read Version
instance [overlap ok] Eq Version
instance [overlap ok] Show Method
instance [overlap ok] Read Method
instance [overlap ok] Eq Method
instance [overlap ok] Read HeaderPair
instance [overlap ok] Show HeaderPair
instance [overlap ok] Show RsFlags
instance [overlap ok] Read RsFlags
instance [overlap ok] Show Input
instance [overlap ok] Read Input
instance [overlap ok] Show Response
instance [overlap ok] Read RqBody
instance [overlap ok] Show RqBody
instance [overlap ok] Show Request
instance [overlap ok] Read Request
instance [overlap ok] HasHeaders Headers
instance [overlap ok] HasHeaders Request
instance [overlap ok] HasHeaders Response
instance [overlap ok] Show Version

module Happstack.Server.MessageWrap
queryInput :: SURI -> [(String, Input)]
bodyInput :: Request -> [(String, Input)]

-- | Decodes application/x-www-form-urlencoded inputs.
formDecode :: String -> [(String, Input)]
decodeBody :: Maybe ContentType -> ByteString -> [(String, Input)]

-- | Decodes multipart/form-data input.
multipartDecode :: [(String, String)] -> ByteString -> [(String, Input)]
bodyPartToInput :: BodyPart -> (String, Input)

-- | Packs a string into an Input of type <a>text/plain</a>
simpleInput :: String -> Input

-- | The default content-type for variables.
defaultInputType :: ContentType

-- | Get the path components from a String.
pathEls :: String -> [String]

-- | Like <a>Read</a> except Strings and Chars not quoted.
class Read a => ReadString a
readString :: ReadString a => String -> a
instance [overlap ok] ReadString Char
instance [overlap ok] ReadString [Char]
instance [overlap ok] ReadString SURI
instance [overlap ok] ReadString Float
instance [overlap ok] ReadString Double
instance [overlap ok] ReadString Int

module Happstack.Server.HTTP.LowLevel
request :: Conf -> Handle -> Host -> (Request -> IO Response) -> IO ()

-- | Unserializes the bytestring into a response. If there is an error it
--   will return <tt>Left msg</tt>.
parseResponse :: ByteString -> Either String Response

-- | Serializes the request to the given handle
putRequest :: Handle -> Request -> IO ()

-- | Bind and listen port
listen :: Conf -> (Request -> IO Response) -> IO ()

-- | Use a previously bind port and listen
listen' :: Socket -> Conf -> (Request -> IO Response) -> IO ()
listenOn :: Int -> IO Socket

module Happstack.Server.HTTP.Client

-- | Sends the serialized request to the host defined in the request and
--   attempts to parse response upon arrival.
getResponse :: Request -> IO (Either String Response)
unproxify :: Request -> Request
unrproxify :: String -> [(String, String)] -> Request -> Request

module Happstack.Server.XSLT

-- | Note that the xsl file must have .xsl suffix.
xsltFile :: XSLPath -> FilePath -> FilePath -> IO ()

-- | Uses the provided xsl file to transform the given string. This
--   function creates temporary files during its execution, but guarantees
--   their cleanup.
xsltString :: XSLPath -> String -> String

-- | Uses <a>xsltString</a> to transform the given XML <a>Element</a> into
--   a a <a>String</a>.
xsltElem :: XSLPath -> Element -> String

-- | Performs an XSL transformation with lists of ByteStrings instead of a
--   String.
xsltFPS :: XSLPath -> [ByteString] -> [ByteString]

-- | Equivalent to <a>xsltFPS</a> but does not hide the inherent IO of the
--   low-level ByteString operations.
xsltFPSIO :: XSLPath -> [ByteString] -> IO [ByteString]
type XSLPath = FilePath

-- | Use <tt>xsltproc</tt> to transform XML.
xsltproc :: XSLTCmd

-- | Use <tt>saxon</tt> to transform XML.
saxon :: XSLTCmd
procFPSIO :: XSLTCommand -> XSLPath -> [ByteString] -> IO [ByteString]
procLBSIO :: XSLTCmd -> XSLPath -> ByteString -> IO ByteString
type XSLTCommand = XSLPath -> FilePath -> FilePath -> (FilePath, [String])
data XSLTCmd
instance [overlap ok] Data XSLTCmd
instance [overlap ok] Show XSLTCmd
instance [overlap ok] Read XSLTCmd
instance [overlap ok] Eq XSLTCmd
instance [overlap ok] Ord XSLTCmd
instance [overlap ok] Sat (ctx XSLTCmd) => Data ctx XSLTCmd
instance [overlap ok] Typeable XSLTCmd
instance [overlap ok] Default XSLTCmd


-- | SimpleHTTP provides a back-end independent API for handling HTTP
--   requests.
--   
--   By default, the built-in HTTP server will be used. However, other
--   back-ends like CGI/FastCGI can be used if so desired.
--   
--   So the general nature of <a>simpleHTTP</a> is just what you'd expect
--   from a web application container. First you figure out which function
--   is going to process your request, process the request to generate a
--   response, then return that response to the client. The web application
--   container is started with <a>simpleHTTP</a>, which takes a
--   configuration and a response-building structure (<a>ServerPartT</a>
--   which I'll return to in a moment), picks the first handler that is
--   willing to accept the request, and passes the request in to the
--   handler. A simple <a>hello world</a> style Happstack simpleHTTP server
--   looks like:
--   
--   <pre>
--   main = simpleHTTP nullConf $ return "Hello World!"
--   </pre>
--   
--   <tt>simpleHTTP nullConf</tt> creates a HTTP server on port 8000.
--   return "Hello World!" creates a <a>ServerPartT</a> that just returns
--   that text.
--   
--   <a>ServerPartT</a> is the basic response builder. As you might expect,
--   it's a container for a function that takes a Request and converts it
--   to a response suitable for sending back to the server. Most of the
--   time though you don't even need to worry about that as
--   <a>ServerPartT</a> hides almost all the machinery for building your
--   response by exposing a few type classes.
--   
--   <a>ServerPartT</a> is a pretty rich monad. You can interact with your
--   request, your response, do IO, etc. Here is a do block that validates
--   basic authentication. It takes a realm name as a string, a Map of
--   username to password and a server part to run if authentication fails.
--   
--   <a>basicAuth</a> acts like a guard, and only produces a response when
--   authentication fails. So put it before any <a>ServerPartT</a> for
--   which you want to demand authentication, in any collection of
--   <a>ServerPartT</a>s.
--   
--   <pre>
--   main = simpleHTTP nullConf $ myAuth, return "Hello World!"
--       where
--           myAuth = basicAuth' "Test"
--               (M.fromList [("hello", "world")]) (return "Login Failed")
--   </pre>
--   
--   <pre>
--   basicAuth' realmName authMap unauthorizedPart =
--      do
--          let validLogin name pass = M.lookup name authMap == Just pass
--          let parseHeader = break (':'==) . Base64.decode . B.unpack . B.drop 6
--          authHeader &lt;- getHeaderM "authorization"
--          case authHeader of
--              Nothing -&gt; err
--              Just x  -&gt; case parseHeader x of
--                  (name, ':':pass) | validLogin name pass -&gt; mzero
--                                     | otherwise -&gt; err
--                  _                                       -&gt; err
--      where
--          err = do
--              unauthorized ()
--              setHeaderM headerName headerValue
--              unauthorizedPart
--          headerValue = "Basic realm=\"" ++ realmName ++ "\""
--          headerName  = "WWW-Authenticate"
--   </pre>
--   
--   Here is another example that uses <a>liftIO</a> to embed IO in a
--   request process:
--   
--   <pre>
--   main = simpleHTTP nullConf $ myPart
--   myPart = do
--     line &lt;- liftIO $ do -- IO
--         putStr "return? "
--         getLine
--     when (take 2 line /= "ok") $ (notfound () &gt;&gt; return "refused")
--     return "Hello World!"
--   </pre>
--   
--   This example will ask in the console "return? " if you type "ok" it
--   will show "Hello World!" and if you type anything else it will return
--   a 404.
module Happstack.Server.SimpleHTTP

-- | Use the built-in web-server to serve requests according to a
--   <a>ServerPartT</a>. Use <a>msum</a> to pick the first handler from a
--   list of handlers that doesn't call <a>mzero</a>. This function always
--   binds o IPv4 ports until Network module is fixed to support IPv6 in a
--   portable way. Use <a>simpleHTTPWithSocket</a> with custom socket if
--   you want different behaviour.
simpleHTTP :: ToMessage a => Conf -> ServerPartT IO a -> IO ()

-- | A combination of <a>simpleHTTP''</a> and <a>mapServerPartT</a>. See
--   <a>mapServerPartT</a> for a discussion of the first argument of this
--   function. This function always binds to IPv4 ports until Network
--   module is fixed to support IPv6 in a portable way. Use
--   <a>simpleHTTPWithSocket</a> with custom socket if you want different
--   behaviour.
simpleHTTP' :: (ToMessage b, Monad m, Functor m) => (UnWebT m a -> UnWebT IO b) -> Conf -> ServerPartT m a -> IO ()

-- | Generate a result from a <a>ServerPartT</a> and a <a>Request</a>. This
--   is mainly used by CGI (and fast-cgi) wrappers.
simpleHTTP'' :: (ToMessage b, Monad m, Functor m) => ServerPartT m b -> Request -> m Response

-- | Run <a>simpleHTTP</a> with a previously bound socket. Useful if you
--   want to run happstack as user on port 80. Use something like this:
--   
--   <pre>
--   import System.Posix.User (setUserID, UserEntry(..), getUserEntryForName)
--   
--   main = do
--       let conf = nullConf { port = 80 }
--       socket &lt;- bindPort conf
--       -- do other stuff as root here
--       getUserEntryForName "www" &gt;&gt;= setUserID . userID
--       -- finally start handling incoming requests
--       tid &lt;- forkIO $ simpleHTTPWithSocket socket conf impl
--   </pre>
--   
--   Note: It's important to use the same conf (or at least the same port)
--   for <a>bindPort</a> and <a>simpleHTTPWithSocket</a>.
simpleHTTPWithSocket :: ToMessage a => Socket -> Conf -> ServerPartT IO a -> IO ()

-- | Like <a>simpleHTTP'</a> with a socket.
simpleHTTPWithSocket' :: (ToMessage b, Monad m, Functor m) => (UnWebT m a -> UnWebT IO b) -> Socket -> Conf -> ServerPartT m a -> IO ()

-- | Bind port and return the socket for <a>simpleHTTPWithSocket</a>. This
--   function always binds to IPv4 ports until Network module is fixed to
--   support IPv6 in a portable way.
bindPort :: Conf -> IO Socket

-- | Parse command line options into a <a>Conf</a>.
parseConfig :: [String] -> Either [String] Conf

-- | ServerPartT is a container for processing requests and returning
--   results.
newtype ServerPartT m a
ServerPartT :: ReaderT Request (WebT m) a -> ServerPartT m a
unServerPartT :: ServerPartT m a -> ReaderT Request (WebT m) a

-- | An alias for using ServerPartT when using the IO.
type ServerPart a = ServerPartT IO a

-- | particularly useful when combined with runWebT to produce a <tt>m
--   (Maybe Response)</tt> from a request.
runServerPartT :: ServerPartT m a -> Request -> WebT m a

-- | Used to manipulate the containing monad. Very useful when embedding a
--   monad into a <a>ServerPartT</a>, since <a>simpleHTTP</a> requires a
--   <tt>ServerPartT IO a</tt>. Refer to <a>WebT</a> for an explanation of
--   the structure of the monad.
--   
--   Here is an example. Suppose you want to embed an <a>ErrorT</a> into
--   your <a>ServerPartT</a> to enable <a>throwError</a> and
--   <a>catchError</a> in your <a>Monad</a>.
--   
--   <pre>
--   type MyServerPartT e m a = ServerPartT (ErrorT e m) a
--   </pre>
--   
--   Now suppose you want to pass <tt>MyServerPartT</tt> into a function
--   that demands a <tt>ServerPartT IO a</tt> (e.g. <a>simpleHTTP</a>). You
--   can provide the function:
--   
--   <pre>
--   unpackErrorT :: (Monad m, Show e) =&gt; UnWebT (ErrorT e m) a -&gt; UnWebT m a
--   unpackErrorT et = do
--      eitherV &lt;- runErrorT et
--      return $ case eitherV of
--          Left err -&gt; Just (Left $ toResponse $ "Catastrophic failure " ++ show err
--                           , Set $ Dual $ Endo $ \r -&gt; r{rsCode = 500})
--          Right x -&gt; x
--   </pre>
--   
--   With <tt>unpackErrorT</tt> you can now call <a>simpleHTTP</a>. Just
--   wrap your <tt>ServerPartT</tt> list.
--   
--   <pre>
--   simpleHTTP nullConf $ mapServerPartT unpackErrorT (myPart `catchError` myHandler)
--   </pre>
--   
--   Or alternatively:
--   
--   <pre>
--   simpleHTTP' unpackErrorT nullConf (myPart `catchError` myHandler)
--   </pre>
--   
--   Also see <a>spUnwrapErrorT</a> for a more sophisticated version of
--   this function.
mapServerPartT :: (UnWebT m a -> UnWebT n b) -> (ServerPartT m a -> ServerPartT n b)

-- | A variant of <a>mapServerPartT</a> where the first argument also takes
--   a request. Useful if you want to <a>runServerPartT</a> on a different
--   <a>ServerPartT</a> inside your monad (see <a>spUnwrapErrorT</a>).
mapServerPartT' :: (Request -> UnWebT m a -> UnWebT n b) -> (ServerPartT m a -> ServerPartT n b)
withRequest :: (Request -> WebT m a) -> ServerPartT m a

-- | A constructor for a <a>ServerPartT</a> when you don't care about the
--   request.
anyRequest :: Monad m => WebT m a -> ServerPartT m a

-- | The basic response building object.
newtype WebT m a
WebT :: ErrorT Response (FilterT (Response) (MaybeT m)) a -> WebT m a
unWebT :: WebT m a -> ErrorT Response (FilterT (Response) (MaybeT m)) a

-- | It is worth discussing the unpacked structure of <a>WebT</a> a bit as
--   it's exposed in <a>mapServerPartT</a> and <a>mapWebT</a>.
--   
--   A fully unpacked <a>WebT</a> has a structure that looks like:
--   
--   <pre>
--   ununWebT $ WebT m a :: m (Maybe (Either Response a, FilterFun Response))
--   </pre>
--   
--   So, ignoring <tt>m</tt>, as it is just the containing <a>Monad</a>,
--   the outermost layer is a <a>Maybe</a>. This is <a>Nothing</a> if
--   <a>mzero</a> was called or <tt><a>Just</a> (<a>Either</a>
--   <a>Response</a> a, <a>SetAppend</a> (<a>Endo</a>
--   <a>Response</a>))</tt> if <a>mzero</a> wasn't called. Inside the
--   <a>Maybe</a>, there is a pair. The second element of the pair is our
--   filter function <tt><a>FilterFun</a> <a>Response</a></tt>.
--   <tt><a>FilterFun</a> <a>Response</a></tt> is a type alias for
--   <tt><a>SetAppend</a> (<a>Dual</a> (<a>Endo</a> <a>Response</a>))</tt>.
--   This is just a wrapper for a <tt><a>Response</a> -&gt;
--   <a>Response</a></tt> function with a particular <a>Monoid</a>
--   behavior. The value
--   
--   <pre>
--   Append (Dual (Endo f))
--   </pre>
--   
--   Causes f to be composed with the previous filter.
--   
--   <pre>
--   Set (Dual (Endo f))
--   </pre>
--   
--   Causes f to not be composed with the previous filter.
--   
--   Finally, the first element of the pair is either <tt>Left
--   Response</tt> or <tt>Right a</tt>.
--   
--   Another way of looking at all these pieces is from the behaviors they
--   control. The <a>Maybe</a> controls the <a>mzero</a> behavior. <tt>Set
--   (Endo f)</tt> comes from the <a>setFilter</a> behavior. Likewise,
--   <tt>Append (Endo f)</tt> is from <a>composeFilter</a>. <tt>Left
--   Response</tt> is what you get when you call <a>finishWith</a> and
--   <tt>Right a</tt> is the normal exit.
--   
--   An example case statement looks like:
--   
--   <pre>
--   ex1 webt = do
--     val &lt;- ununWebT webt
--     case val of
--         Nothing -&gt; Nothing  -- this is the interior value when mzero was used
--         Just (Left r, f) -&gt; Just (Left r, f) -- r is the value that was passed into "finishWith"
--                                              -- f is our filter function
--         Just (Right a, f) -&gt; Just (Right a, f) -- a is our normal monadic value
--                                                -- f is still our filter function
--   </pre>
type UnWebT m a = m (Maybe (Either Response a, FilterFun Response))

-- | <tt>FilterFun</tt> is a lot more fun to type than <tt>SetAppend (Dual
--   (Endo a))</tt>.
type FilterFun a = SetAppend (Dual (Endo a))

-- | An alias for WebT when using IO.
type Web a = WebT IO a

-- | For wrapping a <a>WebT</a> back up. <tt>mkWebT . ununWebT = id</tt>
mkWebT :: UnWebT m a -> WebT m a

-- | For when you really need to unpack a <a>WebT</a> entirely (and not
--   just unwrap the first layer with <a>unWebT</a>).
ununWebT :: WebT m a -> UnWebT m a

-- | Takes your <a>WebT</a>, if it is <a>mempty</a> it returns
--   <a>Nothing</a> else it converts the value to a <a>Response</a> and
--   applies your filter to it.
runWebT :: (Functor m, ToMessage b) => WebT m b -> m (Maybe Response)

-- | See <a>mapServerPartT</a> for a discussion of this function.
mapWebT :: (UnWebT m a -> UnWebT n b) -> (WebT m a -> WebT n b)

-- | This class is used by <a>path</a> to parse a path component into a
--   value. At present, the instances for number types (Int, Float, etc)
--   just call <a>readM</a>. The instance for <a>String</a> however, just
--   passes the path component straight through. This is so that you can
--   read a path component which looks like this as a <a>String</a>:
--   
--   /somestring/
--   
--   instead of requiring the path component to look like:
--   
--   /"somestring"/
class FromReqURI a
fromReqURI :: FromReqURI a => String -> Maybe a

-- | Used to convert arbitrary types into an HTTP response. You need to
--   implement this if you want to pass <tt>ServerPartT m</tt> containing
--   your type into <a>simpleHTTP</a>.
--   
--   Minimal definition: <a>toMessage</a>.
class ToMessage a
toContentType :: ToMessage a => a -> ByteString
toMessage :: ToMessage a => a -> ByteString
toResponse :: ToMessage a => a -> Response

-- | low-level function to build a <a>Response</a> from a content-type and
--   a <tt>ByteString</tt>
--   
--   Creates a <a>Response</a> in a manner similar to the <a>ToMessage</a>
--   class, but with out requiring an instance declaration.
toResponseBS :: ByteString -> ByteString -> Response

-- | Useful for <a>withData</a> and <tt>getData'</tt> implement this on
--   your preferred type to use those functions.
class FromData a
fromData :: FromData a => RqData a

-- | Yes, this is exactly like <a>ReaderT</a> with new names. Why you ask?
--   Because <tt>ServerT</tt> can lift up a <a>ReaderT</a>. If you did
--   that, it would shadow ServerT's behavior as a ReaderT, thus meaning if
--   you lifted the ReaderT you could no longer modify the <a>Request</a>.
--   This way you can add a <a>ReaderT</a> to your monad stack without any
--   trouble.
class Monad m => ServerMonad m
askRq :: ServerMonad m => m Request
localRq :: ServerMonad m => (Request -> Request) -> m a -> m a
type RqData a = ReaderT ([(String, Input)], [(String, Cookie)]) Maybe a

-- | Deprecated: use <a>mzero</a>.
noHandle :: MonadPlus m => m a

-- | Get a header out of the request.
getHeaderM :: ServerMonad m => String -> m (Maybe ByteString)

-- | Used to ignore all your filters and immediately end the computation. A
--   combination of <a>ignoreFilters</a> and <a>finishWith</a>.
escape :: (WebMonad a m, FilterMonad a m) => m a -> m b

-- | An alternate form of <a>escape</a> that can be easily used within a do
--   block.
escape' :: (WebMonad a m, FilterMonad a m) => a -> m b

-- | Deprecated: use <a>msum</a>.
multi :: Monad m => [ServerPartT m a] -> ServerPartT m a

-- | A set of functions for manipulating filters. A <a>ServerPartT</a>
--   implements <a>FilterMonad</a> <a>Response</a> so these methods are the
--   fundamental ways of manipulating the response object, especially
--   before you've converted your monadic value to a <a>Response</a>.
class Monad m => FilterMonad a m | m -> a
setFilter :: FilterMonad a m => (a -> a) -> m ()
composeFilter :: FilterMonad a m => (a -> a) -> m ()
getFilter :: FilterMonad a m => m b -> m (b, a -> a)

-- | An alias for <tt>setFilter id</tt> It resets all your filters.
ignoreFilters :: FilterMonad a m => m ()

-- | A monoid operation container. If a is a monoid, then <a>SetAppend</a>
--   is a monoid with the following behaviors:
--   
--   <pre>
--   Set    x `mappend` Append y = Set    (x `mappend` y)
--   Append x `mappend` Append y = Append (x `mappend` y)
--   _        `mappend` Set y    = Set y
--   </pre>
--   
--   A simple way of summarizing this is, if the right side is
--   <tt>Append</tt>, then the right is appended to the left. If the right
--   side is <tt>Set</tt>, then the left side is ignored.
data SetAppend a
Set :: a -> SetAppend a
Append :: a -> SetAppend a
newtype FilterT a m b
FilterT :: WriterT (FilterFun a) m b -> FilterT a m b
unFilterT :: FilterT a m b -> WriterT (FilterFun a) m b
class Monad m => WebMonad a m | m -> a
finishWith :: WebMonad a m => a -> m b

-- | Add the cookie with a timeout to the response.
addCookie :: FilterMonad Response m => Seconds -> Cookie -> m ()

-- | Add the list of cookie timeout pairs to the response.
addCookies :: FilterMonad Response m => [(Seconds, Cookie)] -> m ()

-- | Expire the cookie immediately.
expireCookie :: FilterMonad Response m => String -> m ()

-- | Add headers into the response. This method does not overwrite any
--   existing header of the same name, hence the name <a>addHeaderM</a>. If
--   you want to replace a header use <a>setHeaderM</a>.
addHeaderM :: FilterMonad Response m => String -> String -> m ()

-- | Set a header into the response. This will replace an existing header
--   of the same name. Use <a>addHeaderM</a> if you want to add more than
--   one header of the same name.
setHeaderM :: FilterMonad Response m => String -> String -> m ()

-- | Honor an <tt>if-modified-since</tt> header in a <a>Request</a>. If the
--   <a>Request</a> includes the <tt>if-modified-since</tt> header and the
--   <a>Response</a> has not been modified, then return 304 (Not Modified),
--   otherwise return the <a>Response</a>.
ifModifiedSince :: CalendarTime -> Request -> Response -> Response

-- | Deprecated: use <a>composeFilter</a>.
modifyResponse :: FilterMonad a m => (a -> a) -> m ()

-- | Set the return code in your response.
setResponseCode :: FilterMonad Response m => Int -> m ()

-- | Same as <tt><a>setResponseCode</a> status &gt;&gt; return val</tt>.
resp :: FilterMonad Response m => Int -> b -> m b

-- | Respond with <tt>200 OK</tt>.
ok :: FilterMonad Response m => a -> m a

-- | Responds with <tt>502 Bad Gateway</tt>.
badGateway :: FilterMonad Response m => a -> m a

-- | Respond with <tt>500 Interal Server Error</tt>.
internalServerError :: FilterMonad Response m => a -> m a

-- | Respond with <tt>400 Bad Request</tt>.
badRequest :: FilterMonad Response m => a -> m a

-- | Respond with <tt>401 Unauthorized</tt>.
unauthorized :: FilterMonad Response m => a -> m a

-- | Respond with <tt>403 Forbidden</tt>.
forbidden :: FilterMonad Response m => a -> m a

-- | Respond with <tt>404 Not Found</tt>.
notFound :: FilterMonad Response m => a -> m a

-- | Respond with <tt>303 See Other</tt>.
seeOther :: (FilterMonad Response m, ToSURI uri) => uri -> res -> m res

-- | Respond with <tt>302 Found</tt>.
found :: (FilterMonad Response m, ToSURI uri) => uri -> res -> m res

-- | Respond with <tt>301 Moved Permanently</tt>.
movedPermanently :: (FilterMonad Response m, ToSURI a) => a -> res -> m res

-- | Respond with <tt>307 Temporary Redirect</tt>.
tempRedirect :: (FilterMonad Response m, ToSURI a) => a -> res -> m res

-- | Guard using an arbitrary function on the request.
guardRq :: (ServerMonad m, MonadPlus m) => (Request -> Bool) -> m ()

-- | Pop a path element and run the <a>ServerPartT</a> if it matches the
--   given string.
--   
--   The path element can not contain '/'. See also <a>dirs</a>.
dir :: (ServerMonad m, MonadPlus m) => String -> m a -> m a

-- | Guard against a <a>FilePath</a>. Unlike <a>dir</a> the <a>FilePath</a>
--   may contain '/'. If the guard succeeds, the matched elements will be
--   popped from the directory stack.
--   
--   <pre>
--   dirs "foo/bar" $ ...
--   </pre>
--   
--   See also: <a>dir</a>.
dirs :: (ServerMonad m, MonadPlus m) => FilePath -> m a -> m a

-- | Guard against the host.
host :: (ServerMonad m, MonadPlus m) => String -> m a -> m a

-- | Lookup the host header and pass it to the handler.
withHost :: (ServerMonad m, MonadPlus m) => (String -> m a) -> m a

-- | Guard against the method. Note, this function also guards against any
--   remaining path segments. This function is deprecated. You can probably
--   just use methodSP (or methodM) now.
method :: (MatchMethod method, Monad m) => method -> WebT m a -> ServerPartT m a

-- | Guard against the method. Note, this function also guards against any
--   remaining path segments.
methodSP :: (ServerMonad m, MonadPlus m, MatchMethod method) => method -> m b -> m b

-- | Guard against the method. This function also guards against any
--   remaining path segments. See <a>methodOnly</a> for the version that
--   guards only by method
methodM :: (ServerMonad m, MonadPlus m, MatchMethod method) => method -> m ()

-- | Guard against the method only. (as opposed to <a>methodM</a>)
methodOnly :: (ServerMonad m, MonadPlus m, MatchMethod method) => method -> m ()

-- | Guard against non-empty remaining path segments.
nullDir :: (ServerMonad m, MonadPlus m) => m ()

-- | Pop a path element and parse it using the <a>fromReqURI</a> in the
--   <a>FromReqURI</a> class.
path :: (FromReqURI a, MonadPlus m, ServerMonad m) => (a -> m b) -> m b

-- | Pop any path element and ignore when chosing a <a>ServerPartT</a> to
--   handle the request.
anyPath :: (ServerMonad m, MonadPlus m) => m r -> m r

-- | Deprecated: use <a>anyPath</a>.
anyPath' :: (ServerMonad m, MonadPlus m) => m r -> m r

-- | Guard which checks that the Request URI ends in '/'. Useful for
--   distinguishing between <tt>foo</tt> and <tt>foo/</tt>
trailingSlash :: (ServerMonad m, MonadPlus m) => m ()

-- | Retrieve data from the input query or the cookies.
withData :: (FromData a, MonadPlus m, ServerMonad m) => (a -> m r) -> m r

-- | <a>withDataFn</a> is like <a>withData</a>, but you pass in a
--   <a>RqData</a> monad for reading.
withDataFn :: (MonadPlus m, ServerMonad m) => RqData a -> (a -> m r) -> m r

-- | Parse your request with a <a>RqData</a> (a ReaderT, basically) For
--   example here is a simple <tt>GET</tt> or <tt>POST</tt> variable based
--   authentication guard. It handles the request with
--   <tt>errorHandler</tt> if authentication fails.
--   
--   <pre>
--   myRqData = do
--       username &lt;- lookInput "username"
--       password &lt;- lookInput "password"
--       return (username, password)
--   checkAuth errorHandler = do
--       d &lt;- getData myRqDataA
--       case d of
--           Nothing -&gt; errorHandler
--           Just a | isValid a -&gt; mzero
--           Just a | otherwise -&gt; errorHandler
--   </pre>
getDataFn :: ServerMonad m => RqData a -> m (Maybe a)

-- | An variant of <a>getData</a> that uses <a>FromData</a> to chose your
--   <a>RqData</a> for you. The example from <a>getData</a> becomes:
--   
--   <pre>
--   myRqData = do
--      username &lt;- lookInput "username"
--      password &lt;- lookInput "password"
--      return (username, password)
--   instance FromData (String,String) where
--      fromData = myRqData
--   checkAuth errorHandler = do
--      d &lt;- getData'
--      case d of
--          Nothing -&gt; errorHandler
--          Just a | isValid a -&gt; mzero
--          Just a | otherwise -&gt; errorHandler
--   </pre>
getData :: (ServerMonad m, FromData a) => m (Maybe a)

-- | Run an IO action and, if it returns <tt>Just</tt>, pass it to the
--   second argument.
require :: (MonadIO m, MonadPlus m) => IO (Maybe a) -> (a -> m r) -> m r

-- | A variant of require that can run in any monad, not just IO.
requireM :: (MonadTrans t, Monad m, MonadPlus (t m)) => m (Maybe a) -> (a -> t m r) -> t m r

-- | A simple HTTP basic authentication guard.
basicAuth :: (WebMonad Response m, ServerMonad m, FilterMonad Response m, MonadPlus m) => String -> Map String String -> m a -> m a

-- | Grab the rest of the URL (dirs + query) and passes it to your handler.
uriRest :: ServerMonad m => (String -> m a) -> m a

-- | <a>flatten</a> turns your arbitrary <tt>m a</tt> and converts it too a
--   <tt>m <a>Response</a></tt> with <a>toResponse</a>.
flatten :: (ToMessage a, Functor f) => f a -> f Response

-- | This is kinda like a very oddly shaped <a>mapServerPartT</a> or
--   <a>mapWebT</a> You probably want one or the other of those.
localContext :: Monad m => (WebT m a -> WebT m' a) -> ServerPartT m a -> ServerPartT m' a

-- | <a>proxyServe</a> is for creating <a>ServerPartT</a>s that proxy. The
--   sole argument <tt>[String]</tt> is a list of allowed domains for
--   proxying. This matches the domain part of the request and the wildcard
--   * can be used. E.g.
--   
--   <ul>
--   <li>"*" to match anything.</li>
--   <li>"*.example.com" to match anything under example.com</li>
--   <li>"example.com" to match just example.com</li>
--   </ul>
--   
--   TODO: annoyingly enough, this method eventually calls escape, so any
--   headers you set won't be used, and the computation immediatly ends.
proxyServe :: (MonadIO m, WebMonad Response m, ServerMonad m, MonadPlus m, FilterMonad Response m) => [String] -> m Response

-- | This is a reverse proxy implementation. See <a>unrproxify</a>.
--   
--   TODO: this would be more useful if it didn't call <a>escape</a>, just
--   like proxyServe'.
rproxyServe :: MonadIO m => String -> [(String, String)] -> ServerPartT m Response

-- | What is this for, exactly? I don't understand why <tt>Show a</tt> is
--   even in the context Deprecated: This function appears to do nothing at
--   all. If it use it, let us know why.
debugFilter :: (MonadIO m, Show a) => ServerPartT m a -> ServerPartT m a

-- | Again, why is this useful? Deprecated: No idea why this function would
--   be useful. If you use it, please tell us.
applyRequest :: (ToMessage a, Monad m, Functor m) => ServerPartT m a -> Request -> Either (m Response) b

-- | Useful inside the <a>RqData</a> monad. Gets the named input parameter
--   (either from a <tt>POST</tt> or a <tt>GET</tt> request).
lookInput :: String -> RqData Input

-- | Get the named input parameter as a <a>ByteString</a>.
lookBS :: String -> RqData ByteString

-- | Get the named input as a <a>String</a>.
look :: String -> RqData String

-- | Get the named cookie. The cookie name is case insensitive.
lookCookie :: String -> RqData Cookie

-- | Get the named cookie as a <a>String</a>.
lookCookieValue :: String -> RqData String

-- | Get the named cookie as the requested <a>Read</a> type.
readCookieValue :: Read a => String -> RqData a

-- | Like <a>look</a>, but <a>Read</a>s for you.
lookRead :: Read a => String -> RqData a

-- | Get all the input parameters and convert them to a <a>String</a>.
lookPairs :: RqData [(String, String)]

-- | Use <tt>cmd</tt> to transform XML against <tt>xslPath</tt>. This
--   function only acts if the content-type is <tt>application/xml</tt>.
xslt :: (MonadIO m, MonadPlus m, ToMessage r) => XSLTCmd -> XSLPath -> m r -> m Response
doXslt :: MonadIO m => XSLTCmd -> XSLPath -> Response -> m Response

-- | This <a>ServerPart</a> modifier enables the use of <a>throwError</a>
--   and <a>catchError</a> inside the <a>WebT</a> actions, by adding the
--   <a>ErrorT</a> monad transformer to the stack.
--   
--   You can wrap the complete second argument to <a>simpleHTTP</a> in this
--   function.
errorHandlerSP :: (Monad m, Error e) => (Request -> e -> WebT m a) -> ServerPartT (ErrorT e m) a -> ServerPartT m a

-- | An example error Handler to be used with <tt>spUnWrapErrorT</tt>,
--   which returns the error message as a plain text message to the
--   browser.
--   
--   Another possibility is to store the error message, e.g. as a FlashMsg,
--   and then redirect the user somewhere.
simpleErrorHandler :: Monad m => String -> ServerPartT m Response

-- | This is a for use with 'mapServerPartT\'' It it unwraps the interior
--   monad for use with <a>simpleHTTP</a>. If you have a <tt>ServerPartT
--   (ErrorT e m) a</tt>, this will convert that monad into a
--   <tt>ServerPartT m a</tt>. Used with 'mapServerPartT\'' to allow
--   <a>throwError</a> and <a>catchError</a> inside your monad. Eg.
--   
--   <pre>
--   simpleHTTP conf $ mapServerPartT' (spUnWrapErrorT failurePart)  $ myPart `catchError` errorPart
--   </pre>
--   
--   Note that <tt>failurePart</tt> will only be run if <tt>errorPart</tt>
--   threw an error so it doesn't have to be very complex.
spUnwrapErrorT :: Monad m => (e -> ServerPartT m a) -> Request -> UnWebT (ErrorT e m) a -> UnWebT m a

-- | Set the validator which should be used for this particular
--   <a>Response</a> when validation is enabled.
--   
--   Calling this function does not enable validation. That can only be
--   done by enabling the validation in the <a>Conf</a> that is passed to
--   <a>simpleHTTP</a>.
--   
--   You do not need to call this function if the validator set in
--   <a>Conf</a> does what you want already.
--   
--   Example: (use <a>noopValidator</a> instead of the default supplied by
--   <a>validateConf</a>)
--   
--   <pre>
--   simpleHTTP validateConf . anyRequest $ ok . setValidator noopValidator =&lt;&lt; htmlPage
--   </pre>
--   
--   See also: <a>validateConf</a>, <a>wdgHTMLValidator</a>,
--   <a>noopValidator</a>, <a>lazyProcValidator</a>
setValidator :: (Response -> IO Response) -> Response -> Response

-- | ServerPart version of <a>setValidator</a>.
--   
--   Example: (Set validator to <a>noopValidator</a>)
--   
--   <pre>
--   simpleHTTP validateConf $ setValidatorSP noopValidator (dir "ajax" ... )
--   </pre>
setValidatorSP :: (Monad m, ToMessage r) => (Response -> IO Response) -> m r -> m Response

-- | Extend <a>nullConf</a> by enabling validation and setting
--   <a>wdgHTMLValidator</a> as the default validator for
--   <tt>text/html</tt>.
--   
--   Example:
--   
--   <pre>
--   simpleHTTP validateConf . anyRequest $ ok htmlPage
--   </pre>
validateConf :: Conf

-- | Actually perform the validation on a <a>Response</a>.
--   
--   Run the validator specified in the <a>Response</a>. If none is provide
--   use the supplied default instead.
--   
--   Note: This function will run validation unconditionally. You probably
--   want <a>setValidator</a> or <a>validateConf</a>.
runValidator :: (Response -> IO Response) -> Response -> IO Response

-- | Validate <tt>text/html</tt> content with <tt>WDG HTML Validator</tt>.
--   
--   This function expects the executable to be named <tt>validate</tt> and
--   it must be in the default <tt>PATH</tt>.
--   
--   See also: <a>setValidator</a>, <a>validateConf</a>,
--   <a>lazyProcValidator</a>.
wdgHTMLValidator :: (MonadIO m, ToMessage r) => r -> m Response

-- | A validator which always succeeds.
--   
--   Useful for selectively disabling validation. For example, if you are
--   sending down HTML fragments to an AJAX application and the default
--   validator only understands complete documents.
noopValidator :: Response -> IO Response

-- | Validate the <a>Response</a> using an external application.
--   
--   If the external application returns 0, the original response is
--   returned unmodified. If the external application returns non-zero, a
--   <a>Response</a> containing the error messages and original response
--   body is returned instead.
--   
--   This function also takes a predicate filter which is applied to the
--   content-type of the response. The filter will only be applied if the
--   predicate returns true.
--   
--   NOTE: This function requirse the use of -threaded to avoid blocking.
--   However, you probably need that for Happstack anyway.
--   
--   See also: <a>wdgHTMLValidator</a>.
lazyProcValidator :: FilePath -> [String] -> Maybe FilePath -> Maybe [(String, String)] -> (Maybe ByteString -> Bool) -> Response -> IO Response
instance [overlap ok] Eq a => Eq (SetAppend a)
instance [overlap ok] Show a => Show (SetAppend a)
instance [overlap ok] Monad m => Monad (FilterT a m)
instance [overlap ok] MonadTrans (FilterT a)
instance [overlap ok] Functor m => Functor (FilterT a m)
instance [overlap ok] MonadIO m => MonadIO (FilterT a m)
instance [overlap ok] MonadIO m => MonadIO (WebT m)
instance [overlap ok] Functor m => Functor (WebT m)
instance [overlap ok] Monad m => Monad (ServerPartT m)
instance [overlap ok] MonadIO m => MonadIO (ServerPartT m)
instance [overlap ok] Monad m => MonadPlus (ServerPartT m)
instance [overlap ok] Functor m => Functor (ServerPartT m)
instance [overlap ok] MatchMethod ()
instance [overlap ok] MatchMethod (Method -> Bool)
instance [overlap ok] MatchMethod [Method]
instance [overlap ok] MatchMethod Method
instance [overlap ok] Xml a => ToMessage a
instance [overlap ok] ToMessage Response
instance [overlap ok] ToMessage Html
instance [overlap ok] ToMessage Html
instance [overlap ok] ToMessage a => ToMessage (Maybe a)
instance [overlap ok] ToMessage Integer
instance [overlap ok] ToMessage String
instance [overlap ok] ToMessage ()
instance [overlap ok] ToMessage [Element]
instance [overlap ok] FromData a => FromData (Maybe a)
instance [overlap ok] (FromData a, FromData b, FromData c, FromData d) => FromData (a, b, c, d)
instance [overlap ok] (FromData a, FromData b, FromData c) => FromData (a, b, c)
instance [overlap ok] (FromData a, FromData b) => FromData (a, b)
instance [overlap ok] (Eq a, Show a, Xml a, Data a) => FromData a
instance [overlap ok] FromReqURI Double
instance [overlap ok] FromReqURI Float
instance [overlap ok] FromReqURI Integer
instance [overlap ok] FromReqURI Int
instance [overlap ok] FromReqURI String
instance [overlap ok] MonadWriter w m => MonadWriter w (WebT m)
instance [overlap ok] MonadError e m => MonadError e (WebT m)
instance [overlap ok] MonadState st m => MonadState st (WebT m)
instance [overlap ok] MonadReader r m => MonadReader r (WebT m)
instance [overlap ok] (Monad m, Functor m) => Applicative (WebT m)
instance [overlap ok] Monad m => Monoid (WebT m a)
instance [overlap ok] Monad m => FilterMonad Response (WebT m)
instance [overlap ok] Monad m => MonadPlus (WebT m)
instance [overlap ok] MonadTrans WebT
instance [overlap ok] Monad m => WebMonad Response (WebT m)
instance [overlap ok] Error Response
instance [overlap ok] Monad m => Monad (WebT m)
instance [overlap ok] Monad m => FilterMonad a (FilterT a m)
instance [overlap ok] Functor SetAppend
instance [overlap ok] Monoid a => Monoid (SetAppend a)
instance [overlap ok] (Error e, ServerMonad m) => ServerMonad (ErrorT e m)
instance [overlap ok] Monad m => ServerMonad (ServerPartT m)
instance [overlap ok] Monad m => WebMonad Response (ServerPartT m)
instance [overlap ok] Monad m => FilterMonad Response (ServerPartT m)
instance [overlap ok] (Monad m, MonadReader r m) => MonadReader r (ServerPartT m)
instance [overlap ok] (Monad m, MonadError e m) => MonadError e (ServerPartT m)
instance [overlap ok] (Monad m, MonadWriter w m) => MonadWriter w (ServerPartT m)
instance [overlap ok] (Monad m, Functor m) => Applicative (ServerPartT m)
instance [overlap ok] Monad m => Monoid (ServerPartT m a)
instance [overlap ok] MonadTrans ServerPartT


-- | File Serving functions
module Happstack.Server.HTTP.FileServe
type MimeMap = Map String String

-- | Ready collection of common mime types. Except for the first two
--   entries, the mappings come from an Ubuntu 8.04 <i>etc</i>mime.types
--   file.
mimeTypes :: MimeMap
asContentType :: Monad m => String -> (FilePath -> m String)
guessContentType :: MimeMap -> FilePath -> Maybe String
guessContentTypeM :: Monad m => MimeMap -> (FilePath -> m String)

-- | Use sendFile to send the contents of a Handle
sendFileResponse :: String -> FilePath -> Maybe (CalendarTime, Request) -> Integer -> Integer -> Response

-- | Send the contents of a Lazy ByteString
lazyByteStringResponse :: String -> ByteString -> Maybe (CalendarTime, Request) -> Integer -> Integer -> Response

-- | Send the contents of a Lazy ByteString
strictByteStringResponse :: String -> ByteString -> Maybe (CalendarTime, Request) -> Integer -> Integer -> Response

-- | Send the specified file with the specified mime-type using sendFile()
--   
--   NOTE: assumes file exists and is readable by the server. See
--   <a>serveFileUsing</a>.
--   
--   WARNING: No security checks are performed.
filePathSendFile :: (ServerMonad m, MonadIO m) => String -> FilePath -> m Response

-- | Send the specified file with the specified mime-type using Lazy
--   ByteStrings
--   
--   NOTE: assumes file exists and is readable by the server. See
--   <a>serveFileUsing</a>.
--   
--   WARNING: No security checks are performed.
filePathLazy :: (ServerMonad m, MonadIO m) => String -> FilePath -> m Response

-- | Send the specified file with the specified mime-type using Lazy
--   ByteStrings
--   
--   NOTE: assumes file exists and is readable by the server. See
--   <a>serveFileUsing</a>.
--   
--   WARNING: No security checks are performed.
filePathStrict :: (ServerMonad m, MonadIO m) => String -> FilePath -> m Response

-- | Alias for <a>serveFileUsing</a> <a>filePathSendFile</a>
serveFile :: (ServerMonad m, FilterMonad Response m, MonadIO m, MonadPlus m) => (FilePath -> m String) -> FilePath -> m Response

-- | Serve a single, specified file.
--   
--   example 1:
--   
--   Serve using sendfile() and the specified content-type
--   
--   <pre>
--   serveFileUsing filePathSendFile (asContentType "image/jpeg") "/srv/data/image.jpg"
--   </pre>
--   
--   example 2:
--   
--   Serve using a lazy ByteString and the guess the content-type from the
--   extension
--   
--   <pre>
--   serveFileUsing filePathLazy (guessContentTypeM mimeTypes) "/srv/data/image.jpg"
--   </pre>
--   
--   WARNING: No security checks are performed.
serveFileUsing :: (ServerMonad m, FilterMonad Response m, MonadIO m, MonadPlus m) => (String -> FilePath -> m Response) -> (FilePath -> m String) -> FilePath -> m Response

-- | Serve files from a directory and its subdirectories (parameterizable
--   version)
--   
--   Parameterize this function to create functions like, <a>fileServe</a>,
--   <a>fileServeLazy</a>, and <a>fileServeStrict</a>
--   
--   You supply:
--   
--   <ol>
--   <li>a low-level function which takes a content-type and
--   <a>FilePath</a> and generates a Response 2. a function which
--   determines the content-type from the <a>FilePath</a> 3. a list of all
--   the default index files</li>
--   </ol>
--   
--   NOTE: unlike fileServe, there are no index files by default. See
--   <a>defaultIxFiles</a>.
fileServe' :: (WebMonad Response m, ServerMonad m, FilterMonad Response m, MonadIO m, MonadPlus m) => (String -> FilePath -> m Response) -> (FilePath -> m String) -> [FilePath] -> FilePath -> m Response

-- | Serve files from a directory and its subdirectories (sendFile
--   version). Should perform much better than its predecessors.
fileServe :: (WebMonad Response m, ServerMonad m, FilterMonad Response m, MonadIO m, MonadPlus m) => [FilePath] -> FilePath -> m Response

-- | Serve files from a directory and its subdirectories (lazy ByteString
--   version).
--   
--   May leak file handles.
fileServeLazy :: (WebMonad Response m, ServerMonad m, FilterMonad Response m, MonadIO m, MonadPlus m) => [FilePath] -> FilePath -> m Response

-- | Serve files from a directory and its subdirectories (strict ByteString
--   version).
fileServeStrict :: (WebMonad Response m, ServerMonad m, FilterMonad Response m, MonadIO m, MonadPlus m) => [FilePath] -> FilePath -> m Response

-- | Prevents files of the form '.foo' or 'bar/.foo' from being served
blockDotFiles :: (Request -> IO Response) -> Request -> IO Response
defaultIxFiles :: [String]
doIndex :: (ServerMonad m, FilterMonad Response m, MonadIO m, MonadPlus m) => [String] -> MimeMap -> String -> m Response
doIndex' :: (ServerMonad m, FilterMonad Response m, MonadIO m, MonadPlus m) => (String -> FilePath -> m Response) -> (FilePath -> m String) -> [String] -> String -> m Response
doIndexLazy :: (ServerMonad m, FilterMonad Response m, MonadIO m, MonadPlus m) => [String] -> MimeMap -> String -> m Response
doIndexStrict :: (ServerMonad m, FilterMonad Response m, MonadIO m, MonadPlus m) => [String] -> MimeMap -> String -> m Response
errorwrapper :: (MonadIO m, MonadPlus m, FilterMonad Response m) => String -> String -> m Response

-- | return a simple <a>File not found 404 page.</a>
fileNotFound :: (Monad m, FilterMonad Response m) => FilePath -> m Response

-- | Returns True if the given String either starts with a . or is of the
--   form <a>foo/.bar</a>, e.g. the typical *nix convention for hidden
--   files.
isDot :: String -> Bool

module Happstack.Server.StdConfig

-- | Is equal to <a>haskell/Main</a>
binarylocation :: String

-- | Is equal to <a>public/log</a>
loglocation :: String

-- | Convenience function around <a>errorwrapper</a> with the default
--   binary location set to <a>binarylocation</a> and the log location set
--   to <a>loglocation</a>.
errWrap :: (MonadPlus m, FilterMonad Response m, MonadIO m) => m Response

module Happstack.Server.Parts

-- | reads the "Accept-Encoding" header. Then, if possible will compress
--   the response body with methods <a>gzip</a> or <a>deflate</a>
--   
--   Returns the name of the coding chosen
compressedResponseFilter :: (FilterMonad Response m, MonadPlus m, WebMonad Response m, ServerMonad m) => m String

-- | compresses the body of the response with gzip. does not set any
--   headers.
gzipFilter :: FilterMonad Response m => m ()

-- | compresses the body of the response with zlib's deflate method does
--   not set any headers.
deflateFilter :: FilterMonad Response m => m ()

-- | unsupported: a parser for the Accept-Encoding header
encodings :: GenParser Char st [([Char], Maybe Double)]

module Happstack.Server