Safe Haskell	None
Language	Haskell2010

Airship.Types

Synopsis

Documentation

data ETag Source

Constructors

Strong ByteString
Weak ByteString

Instances

Eq ETag Source
Ord ETag Source
Show ETag Source

data Webmachine m a Source

Instances

MonadTrans Webmachine Source
MonadBase b m => MonadBase b (Webmachine m) Source
MonadBaseControl b m => MonadBaseControl b (Webmachine m) Source
Monad m => MonadState ResponseState (Webmachine m) Source
Monad m => Monad (Webmachine m) Source
Monad m => Functor (Webmachine m) Source
Monad m => Applicative (Webmachine m) Source
MonadIO m => MonadIO (Webmachine m) Source
type StM (Webmachine m) a Source

data Request :: *

Information on the request sent by the client. This abstracts away the details of the underlying implementation.

Instances

Show Request

data Response Source

Constructors

Response
Fields _responseStatus :: Status _responseHeaders :: ResponseHeaders _responseBody :: ResponseBody

data ResponseState Source

Constructors

ResponseState
Fields stateHeaders :: ResponseHeaders stateBody :: ResponseBody _params :: HashMap Text Text _dispatchPath :: [Text]

Instances

Monad m => MonadState ResponseState (Webmachine m) Source

data ResponseBody Source

Basically Wai's unexported Response type.

Constructors

ResponseFile FilePath (Maybe FilePart)
ResponseBuilder Builder
ResponseStream StreamingBody
Empty

type ErrorResponses m = Monad m => Map Status [(MediaType, Webmachine m ResponseBody)] Source

defaultRequest :: Request

A default, blank request.

Since 2.0.0

entireRequestBody :: MonadIO m => Request -> m ByteString Source

Reads the entirety of the request body in a single string. This turns the chunks obtained from repeated invocations of requestBody into a lazy ByteString.

etagToByteString :: ETag -> ByteString Source

eitherResponse :: Monad m => UTCTime -> HashMap Text Text -> [Text] -> Request -> Webmachine m Response -> m (Response, Trace) Source

escapedResponse :: Text -> ResponseBody Source

Helper function for building a ResponseBuilder out of HTML-escaped text.

mapWebmachine :: (m1 (Either Response a1, ResponseState, Trace) -> m2 (Either Response a2, ResponseState, Trace)) -> Webmachine m1 a1 -> Webmachine m2 a2 Source

Map both the return value and wrapped computation m.

runWebmachine :: Monad m => UTCTime -> HashMap Text Text -> [Text] -> Request -> Webmachine m a -> m (Either Response a, Trace) Source

request :: Monad m => Webmachine m Request Source

Returns the Request that is currently being processed.

requestTime :: Monad m => Webmachine m UTCTime Source

Returns the time at which this request began processing.

getResponseHeaders :: Monad m => Webmachine m ResponseHeaders Source

Returns the current ResponseHeaders.

getResponseBody :: Monad m => Webmachine m ResponseBody Source

Returns the current ResponseBody.

params :: Monad m => Webmachine m (HashMap Text Text) Source

Returns the bound routing parameters extracted from the routing system (see Airship.Route).

dispatchPath :: Monad m => Webmachine m [Text] Source

putResponseBody :: Monad m => ResponseBody -> Webmachine m () Source

Given a new ResponseBody, replaces the stored body with the new one.

putResponseBS :: Monad m => ByteString -> Webmachine m () Source

Stores the provided ByteString as the responseBody. This is a shortcut for creating a response body with a ResponseBuilder and a bytestring Builder.

halt :: Monad m => Status -> Webmachine m a Source

Immediately halts processing with the provided Status code. The contents of the Webmachine's response body will be streamed back to the client. This is a shortcut for constructing a Response with getResponseHeaders and getResponseBody and passing that response to finishWith.

finishWith :: Monad m => Response -> Webmachine m a Source

Immediately halts processing and writes the provided Response back to the client.

(#>) :: MonadWriter [(k, v)] m => k -> v -> m () Source

The #> operator provides syntactic sugar for the construction of association lists. For example, the following assoc list:

    [("run", "jewels"), ("blue", "suede"), ("zion", "wolf")]

can be represented as such:

    execWriter $ do
      "run" #> "jewels"
      "blue" #> "suede"
      "zion" #> "wolf"

It used in RoutingSpec declarations to indicate that a particular Route maps to a given Resource, but can be used in many other places where association lists are expected, such as contentTypesProvided.