Web.Scotty.Trans

It should be noted that most of the code snippets below depend on the OverloadedStrings language pragma.

The functions in this module allow an arbitrary monad to be embedded in Scotty's monad transformer stack, e.g. for complex endpoint configuration, interacting with databases etc.

Scotty is set up by default for development mode. For production servers, you will likely want to modify settings and the defaultHandler. See the comments on each of these functions for more information.

Please refer to the examples directory and the spec test suite for concrete use cases, e.g. constructing responses, exception handling and useful implementation details.

Running scotty servers

scottyT

Arguments

:: (Monad m, MonadIO n)

=> Port

-> (m Response -> IO Response)

Run monad m into IO, called at each action.

-> ScottyT m ()

-> n ()

Run a scotty application using the warp server. NB: scotty p === scottyT p id

scottyOptsT

Arguments

:: (Monad m, MonadIO n)

=> Options

-> (m Response -> IO Response)

Run monad m into IO, called at each action.

-> ScottyT m ()

-> n ()

Run a scotty application using the warp server, passing extra options. NB: scottyOpts opts === scottyOptsT opts id

scottySocketT :: (Monad m, MonadIO n) => Options -> Socket -> (m Response -> IO Response) -> ScottyT m () -> n ()

Run a scotty application using the warp server, passing extra options, and listening on the provided socket. NB: scottySocket opts sock === scottySocketT opts sock id

data Options

Constructors

Options

Fields

• verbose :: Int

  0 = silent, 1(def) = startup banner

• settings :: Settings

  Warp Settings Note: to work around an issue in warp, the default FD cache duration is set to 0 so changes to static files are always picked up. This likely has performance implications, so you may want to modify this for production servers using setFdCacheDuration.

Instances

Default Options

Defined in Web.Scotty.Internal.Types

Methods

def :: Options

defaultOptions :: Options

scotty-to-WAI

scottyAppT

Arguments

:: (Monad m, Monad n)

=> Options

-> (m Response -> IO Response)

Run monad m into IO, called at each action.

-> ScottyT m ()

-> n Application

Turn a scotty application into a WAI Application, which can be run with any WAI handler. NB: scottyApp === scottyAppT id

Defining Middleware and Routes

Middleware and routes are run in the order in which they are defined. All middleware is run first, followed by the first route that matches. If no route matches, a 404 response is given.

middleware :: Middleware -> ScottyT m ()

Use given middleware. Middleware is nested such that the first declared is the outermost middleware (it has first dibs on the request and last action on the response). Every middleware is run on each request.

get :: MonadUnliftIO m => RoutePattern -> ActionT m () -> ScottyT m ()

get = addroute GET

post :: MonadUnliftIO m => RoutePattern -> ActionT m () -> ScottyT m ()

post = addroute POST

put :: MonadUnliftIO m => RoutePattern -> ActionT m () -> ScottyT m ()

put = addroute PUT

delete :: MonadUnliftIO m => RoutePattern -> ActionT m () -> ScottyT m ()

delete = addroute DELETE

patch :: MonadUnliftIO m => RoutePattern -> ActionT m () -> ScottyT m ()

patch = addroute PATCH

options :: MonadUnliftIO m => RoutePattern -> ActionT m () -> ScottyT m ()

options = addroute OPTIONS

addroute :: MonadUnliftIO m => StdMethod -> RoutePattern -> ActionT m () -> ScottyT m ()

Define a route with a StdMethod, a route pattern representing the path spec, and an Action which may modify the response.

get "/" $ text "beam me up!"

The path spec can include values starting with a colon, which are interpreted as captures. These are parameters that can be looked up with pathParam.

>>> :{
let server = S.get "/foo/:bar" (S.pathParam "bar" >>= S.text)
 in do
      withScotty server $ curl "http://localhost:3000/foo/something"
:}
"something"

matchAny :: MonadUnliftIO m => RoutePattern -> ActionT m () -> ScottyT m ()

Add a route that matches regardless of the HTTP verb.

notFound :: MonadUnliftIO m => ActionT m () -> ScottyT m ()

Specify an action to take if nothing else is found. Note: this _always_ matches, so should generally be the last route specified.

setMaxRequestBodySize

Arguments

:: Kilobytes

Request size limit

-> ScottyT m ()

Set global size limit for the request body. Requests with body size exceeding the limit will not be processed and an HTTP response 413 will be returned to the client. Size limit needs to be greater than 0, otherwise the application will terminate on start.

Route Patterns

capture :: String -> RoutePattern

Standard Sinatra-style route. Named captures are prepended with colons. This is the default route type generated by OverloadedString routes. i.e.

get (capture "/foo/:bar") $ ...

and

{-# LANGUAGE OverloadedStrings #-}
...
get "/foo/:bar" $ ...

are equivalent.

regex :: String -> RoutePattern

Match requests using a regular expression. Named captures are not yet supported.

>>> :{
let server = S.get (S.regex "^/f(.*)r$") $ do
                cap <- S.pathParam "1"
                S.text cap
 in do
      withScotty server $ curl "http://localhost:3000/foo/bar"
:}
"oo/ba"

function :: (Request -> Maybe [Param]) -> RoutePattern

Build a route based on a function which can match using the entire Request object. Nothing indicates the route does not match. A Just value indicates a successful match, optionally returning a list of key-value pairs accessible by param.

>>> :{
let server = S.get (function $ \req -> Just [("version", T.pack $ show $ W.httpVersion req)]) $ do
                v <- S.pathParam "version"
                S.text v
 in do
      withScotty server $ curl "http://localhost:3000/"
:}
"HTTP/1.1"

literal :: String -> RoutePattern

Build a route that requires the requested path match exactly, without captures.

Accessing the Request and its fields

request :: Monad m => ActionT m Request

Get the Request object.

header :: Monad m => Text -> ActionT m (Maybe Text)

Get a request header. Header name is case-insensitive.

headers :: Monad m => ActionT m [(Text, Text)]

Get all the request headers. Header names are case-insensitive.

body :: MonadIO m => ActionT m ByteString

Get the request body.

NB This loads the whole request body in memory at once.

bodyReader :: Monad m => ActionT m (IO ByteString)

Get an IO action that reads body chunks

• This is incompatible with body since body consumes all chunks.

jsonData :: (FromJSON a, MonadIO m) => ActionT m a

Parse the request body as a JSON object and return it.

If the JSON object is malformed, this sets the status to 400 Bad Request, and throws an exception.

If the JSON fails to parse, this sets the status to 422 Unprocessable Entity.

These status codes are as per https://www.restapitutorial.com/httpstatuscodes.html.

NB : Internally this uses body.

Accessing Path, Form and Query Parameters

param :: (Parsable a, MonadIO m) => Text -> ActionT m a

Deprecated: (#204) Not a good idea to treat all parameters identically. Use captureParam, formParam and queryParam instead.

Get a parameter. First looks in captures, then form data, then query parameters.

• Raises an exception which can be caught by catch if parameter is not found.
• If parameter is found, but parseParam fails to parse to the correct type, next is called. This means captures are somewhat typed, in that a route won't match if a correctly typed capture cannot be parsed.

params :: Monad m => ActionT m [Param]

Deprecated: (#204) Not a good idea to treat all parameters identically. Use pathParams, formParams and queryParams instead.

Get all parameters from path, form and query (in that order).

pathParam :: (Parsable a, MonadIO m) => Text -> ActionT m a

Look up a path parameter.

• Raises an exception which can be caught by catch if parameter is not found. If the exception is not caught, scotty will return a HTTP error code 500 ("Internal Server Error") to the client.
• If the parameter is found, but parseParam fails to parse to the correct type, next is called.

Since: 0.20

captureParam :: (Parsable a, MonadIO m) => Text -> ActionT m a

Synonym for pathParam

formParam :: (MonadUnliftIO m, Parsable b) => Text -> ActionT m b

Look up a form parameter.

• Raises an exception which can be caught by catch if parameter is not found. If the exception is not caught, scotty will return a HTTP error code 400 ("Bad Request") to the client.
• This function raises a code 400 also if the parameter is found, but parseParam fails to parse to the correct type.

Since: 0.20

queryParam :: (Parsable a, MonadIO m) => Text -> ActionT m a

Look up a query parameter.

• Raises an exception which can be caught by catch if parameter is not found. If the exception is not caught, scotty will return a HTTP error code 400 ("Bad Request") to the client.
• This function raises a code 400 also if the parameter is found, but parseParam fails to parse to the correct type.

Since: 0.20

pathParamMaybe :: (Parsable a, Monad m) => Text -> ActionT m (Maybe a)

Look up a path parameter. Returns Nothing if the parameter is not found or cannot be parsed at the right type.

NB : Doesn't throw exceptions. In particular, route pattern matching will not continue, so developers must raiseStatus or throw to signal something went wrong.

Since: 0.21

captureParamMaybe :: (Parsable a, Monad m) => Text -> ActionT m (Maybe a)

Look up a capture parameter. Returns Nothing if the parameter is not found or cannot be parsed at the right type.

NB : Doesn't throw exceptions. In particular, route pattern matching will not continue, so developers must raiseStatus or throw to signal something went wrong.

Since: 0.21

formParamMaybe :: (MonadUnliftIO m, Parsable a) => Text -> ActionT m (Maybe a)

Look up a form parameter. Returns Nothing if the parameter is not found or cannot be parsed at the right type.

NB : Doesn't throw exceptions, so developers must raiseStatus or throw to signal something went wrong.

Since: 0.21

queryParamMaybe :: (Parsable a, Monad m) => Text -> ActionT m (Maybe a)

Look up a query parameter. Returns Nothing if the parameter is not found or cannot be parsed at the right type.

NB : Doesn't throw exceptions, so developers must raiseStatus or throw to signal something went wrong.

Since: 0.21

pathParams :: Monad m => ActionT m [Param]

Get path parameters

captureParams :: Monad m => ActionT m [Param]

Get path parameters

formParams :: MonadUnliftIO m => ActionT m [Param]

Get form parameters

queryParams :: Monad m => ActionT m [Param]

Get query parameters

Files

files :: MonadUnliftIO m => ActionT m [File ByteString]

Get list of uploaded files.

NB: Loads all file contents in memory with options defaultParseRequestBodyOptions

filesOpts

Arguments

:: MonadUnliftIO m

=> ParseRequestBodyOptions

-> ([Param] -> [File FilePath] -> ActionT m a)

temp files validation, storage etc

-> ActionT m a

Get list of uploaded temp files and form parameters decoded from multipart payloads.

NB the temp files are deleted when the continuation exits.

data ParseRequestBodyOptions

A data structure that describes the behavior of the parseRequestBodyEx function.

Since: wai-extra-3.0.16.0

Modifying the Response and Redirecting

status :: MonadIO m => Status -> ActionT m ()

Set the HTTP response status.

addHeader :: MonadIO m => Text -> Text -> ActionT m ()

Add to the response headers. Header names are case-insensitive.

setHeader :: MonadIO m => Text -> Text -> ActionT m ()

Set one of the response headers. Will override any previously set value for that header. Header names are case-insensitive.

redirect :: Monad m => Text -> ActionT m a

Redirect to given URL. Like throwing an uncatchable exception. Any code after the call to redirect will not be run.

redirect "http://www.google.com"

OR

redirect "/foo/bar"

Setting Response Body

Note: only one of these should be present in any given route definition, as they completely replace the current Response body.

text :: MonadIO m => Text -> ActionT m ()

html :: MonadIO m => Text -> ActionT m ()

file :: MonadIO m => FilePath -> ActionT m ()

Send a file as the response. Doesn't set the "Content-Type" header, so you probably want to do that on your own with setHeader. Setting a status code will have no effect because Warp will overwrite that to 200 (see sendResponse).

json :: (ToJSON a, MonadIO m) => a -> ActionT m ()

Set the body of the response to the JSON encoding of the given value. Also sets "Content-Type" header to "application/json; charset=utf-8" if it has not already been set.

stream :: MonadIO m => StreamingBody -> ActionT m ()

Set the body of the response to a Source. Doesn't set the "Content-Type" header, so you probably want to do that on your own with setHeader.

raw :: MonadIO m => ByteString -> ActionT m ()

Set the body of the response to the given ByteString value. Doesn't set the "Content-Type" header, so you probably want to do that on your own with setHeader.

nested :: MonadIO m => Application -> ActionT m ()

Nest a whole WAI application inside a Scotty handler. See Web.Scotty for further documentation

Accessing the fields of the Response

getResponseHeaders :: MonadIO m => ActionT m ResponseHeaders

Access the HTTP headers of the Response

SINCE 0.21

getResponseStatus :: MonadIO m => ActionT m Status

Access the HTTP Status of the Response

SINCE 0.21

getResponseContent :: MonadIO m => ActionT m Content

Access the content of the Response

SINCE 0.21

Exceptions

raise

Arguments

:: MonadIO m

=> Text

Error text

-> ActionT m a

Deprecated: Throw an exception instead

Throw a "500 Server Error" StatusError, which can be caught with rescue.

Uncaught exceptions turn into HTTP 500 responses.

raiseStatus :: Monad m => Status -> Text -> ActionT m a

Deprecated: Use status, text, and finish instead

Throw a StatusError exception that has an associated HTTP error code and can be caught with rescue.

Uncaught exceptions turn into HTTP responses corresponding to the given status.

throw :: (MonadIO m, Exception e) => e -> ActionT m a

Throw an exception which can be caught within the scope of the current Action with catch.

If the exception is not caught locally, another option is to implement a global Handler (with defaultHandler) that defines its interpretation and a translation to HTTP error codes.

Uncaught exceptions turn into HTTP 500 responses.

rescue :: (MonadUnliftIO m, Exception e) => ActionT m a -> (e -> ActionT m a) -> ActionT m a

Deprecated: Use catch instead

Catch an exception e.g. a StatusError or a user-defined exception.

raise JustKidding `catch` (\msg -> text msg)

next :: Monad m => ActionT m a

Abort execution of this action and continue pattern matching routes. Like an exception, any code after next is not executed.

NB : Internally, this is implemented with an exception that can only be caught by the library, but not by the user.

As an example, these two routes overlap. The only way the second one will ever run is if the first one calls next.

get "/foo/:bar" $ do
  w :: Text <- pathParam "bar"
  unless (w == "special") next
  text "You made a request to /foo/special"

get "/foo/:baz" $ do
  w <- pathParam "baz"
  text $ "You made a request to: " <> w

finish :: Monad m => ActionT m a

Finish the execution of the current action. Like throwing an uncatchable exception. Any code after the call to finish will not be run.

Since: 0.10.3

defaultHandler :: Monad m => ErrorHandler m -> ScottyT m ()

Global handler for user-defined exceptions.

liftAndCatchIO :: MonadIO m => IO a -> ActionT m a

Deprecated: Use liftIO instead

Catch any synchronous IO exceptions

liftIO :: MonadIO m => IO a -> m a

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

catch

Arguments

:: (MonadUnliftIO m, Exception e)

=> m a

action

-> (e -> m a)

handler

-> m a

Catch a synchronous (but not asynchronous) exception and recover from it.

This is parameterized on the exception type. To catch all synchronous exceptions, use catchAny.

Since: unliftio-0.1.0.0

data StatusError

Deprecated: If it is supposed to be caught, a proper exception type should be defined

E.g. when a parameter is not found in a query string (400 Bad Request) or when parsing a JSON body fails (422 Unprocessable Entity)

Constructors

StatusError Status Text

Deprecated: If it is supposed to be caught, a proper exception type should be defined

Instances

Exception StatusError

Defined in Web.Scotty.Internal.Types

Methods

toException :: StatusError -> SomeException

fromException :: SomeException -> Maybe StatusError

displayException :: StatusError -> String

Show StatusError

Defined in Web.Scotty.Internal.Types

Methods

showsPrec :: Int -> StatusError -> ShowS

show :: StatusError -> String

showList :: [StatusError] -> ShowS

MonadUnliftIO m => MonadError StatusError (ActionT m)

Models the invariant that only StatusErrors can be thrown and caught.

Defined in Web.Scotty.Internal.Types

Methods

throwError :: StatusError -> ActionT m a

catchError :: ActionT m a -> (StatusError -> ActionT m a) -> ActionT m a

data ScottyException

Thrown e.g. when a request is too large

Constructors

RequestTooLarge

MalformedJSON ByteString Text

FailedToParseJSON ByteString Text

PathParameterNotFound Text

QueryParameterNotFound Text

FormFieldNotFound Text

FailedToParseParameter Text Text Text

WarpRequestException InvalidRequest

WaiRequestParseException RequestParseException

ResourceTException InvalidAccess

Instances

Exception ScottyException

Defined in Web.Scotty.Internal.Types

Methods

toException :: ScottyException -> SomeException

fromException :: SomeException -> Maybe ScottyException

displayException :: ScottyException -> String

Show ScottyException

Defined in Web.Scotty.Internal.Types

Methods

showsPrec :: Int -> ScottyException -> ShowS

show :: ScottyException -> String

showList :: [ScottyException] -> ShowS

Parsing Parameters

type Param = (Text, Text)

class Parsable a where

Minimum implemention: parseParam

Minimal complete definition

parseParam

Methods

parseParam :: Text -> Either Text a

Take a Text value and parse it as a, or fail with a message.

parseParamList :: Text -> Either Text [a]

Default implementation parses comma-delimited lists.

parseParamList t = mapM parseParam (T.split (== ',') t)

Instances

Parsable Int16

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Int16

parseParamList :: Text -> Either Text [Int16]

Parsable Int32

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Int32

parseParamList :: Text -> Either Text [Int32]

Parsable Int64

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Int64

parseParamList :: Text -> Either Text [Int64]

Parsable Int8

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Int8

parseParamList :: Text -> Either Text [Int8]

Parsable Word16

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Word16

parseParamList :: Text -> Either Text [Word16]

Parsable Word32

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Word32

parseParamList :: Text -> Either Text [Word32]

Parsable Word64

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Word64

parseParamList :: Text -> Either Text [Word64]

Parsable Word8

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Word8

parseParamList :: Text -> Either Text [Word8]

Parsable ByteString

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text ByteString

parseParamList :: Text -> Either Text [ByteString]

Parsable ByteString

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text ByteString

parseParamList :: Text -> Either Text [ByteString]

Parsable Text

Defined in Web.Scotty.Action

Methods

parseParam :: Text0 -> Either Text0 Text

parseParamList :: Text0 -> Either Text0 [Text]

Parsable Text

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Text

parseParamList :: Text -> Either Text [Text]

Parsable UTCTime

parse a UTCTime timestamp formatted as a ISO 8601 timestamp:

yyyy-mm-ddThh:mm:ssZ , where the seconds can have a decimal part with up to 12 digits and no trailing zeros.

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text UTCTime

parseParamList :: Text -> Either Text [UTCTime]

Parsable Integer

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Integer

parseParamList :: Text -> Either Text [Integer]

Parsable Natural

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Natural

parseParamList :: Text -> Either Text [Natural]

Parsable ()

Checks if parameter is present and is null-valued, not a literal (). If the URI requested is: '/foo?bar=()&baz' then baz will parse as (), where bar will not.

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text ()

parseParamList :: Text -> Either Text [()]

Parsable Bool

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Bool

parseParamList :: Text -> Either Text [Bool]

Parsable Char

Overrides default parseParamList to parse String.

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Char

parseParamList :: Text -> Either Text [Char]

Parsable Double

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Double

parseParamList :: Text -> Either Text [Double]

Parsable Float

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Float

parseParamList :: Text -> Either Text [Float]

Parsable Int

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Int

parseParamList :: Text -> Either Text [Int]

Parsable Word

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text Word

parseParamList :: Text -> Either Text [Word]

Parsable a => Parsable [a]

Defined in Web.Scotty.Action

Methods

parseParam :: Text -> Either Text [a]

parseParamList :: Text -> Either Text [[a]]

readEither :: Read a => Text -> Either Text a

Useful for creating Parsable instances for things that already implement Read. Ex:

instance Parsable Int where parseParam = readEither

Types

data RoutePattern

Instances

IsString RoutePattern

Defined in Web.Scotty.Internal.Types

Methods

fromString :: String -> RoutePattern

type File t = (Text, FileInfo t)

Type parameter t is the file content. Could be () when not needed or a FilePath for temp files instead.

data Content

Constructors

ContentBuilder Builder

ContentFile FilePath

ContentStream StreamingBody

ContentResponse Response

type Kilobytes = Int

type ErrorHandler m = Handler (ActionT m) ()

Specializes a Handler to the ActionT monad

data Handler (m :: Type -> Type) a

Generalized version of Handler

Constructors

Exception e => Handler (e -> m a)

Instances

Monad m => Functor (Handler m)

Defined in Control.Monad.Catch

Methods

fmap :: (a -> b) -> Handler m a -> Handler m b

(<$) :: a -> Handler m b -> Handler m a

Monad Transformers

data ScottyT m a

Instances

Applicative (ScottyT m)

Defined in Web.Scotty.Internal.Types

Methods

pure :: a -> ScottyT m a

(<*>) :: ScottyT m (a -> b) -> ScottyT m a -> ScottyT m b

liftA2 :: (a -> b -> c) -> ScottyT m a -> ScottyT m b -> ScottyT m c

(*>) :: ScottyT m a -> ScottyT m b -> ScottyT m b

(<*) :: ScottyT m a -> ScottyT m b -> ScottyT m a

Functor (ScottyT m)

Defined in Web.Scotty.Internal.Types

Methods

fmap :: (a -> b) -> ScottyT m a -> ScottyT m b

(<$) :: a -> ScottyT m b -> ScottyT m a

Monad (ScottyT m)

Defined in Web.Scotty.Internal.Types

Methods

(>>=) :: ScottyT m a -> (a -> ScottyT m b) -> ScottyT m b

(>>) :: ScottyT m a -> ScottyT m b -> ScottyT m b

return :: a -> ScottyT m a

Monoid a => Monoid (ScottyT m a)

Defined in Web.Scotty.Internal.Types

Methods

mempty :: ScottyT m a

mappend :: ScottyT m a -> ScottyT m a -> ScottyT m a

mconcat :: [ScottyT m a] -> ScottyT m a

Semigroup a => Semigroup (ScottyT m a)

Defined in Web.Scotty.Internal.Types

Methods

(<>) :: ScottyT m a -> ScottyT m a -> ScottyT m a

sconcat :: NonEmpty (ScottyT m a) -> ScottyT m a

stimes :: Integral b => b -> ScottyT m a -> ScottyT m a

data ActionT m a

Instances

MonadTransControl ActionT

Defined in Web.Scotty.Internal.Types

Associated Types

type StT ActionT a

Methods

liftWith :: Monad m => (Run ActionT -> m a) -> ActionT m a

restoreT :: Monad m => m (StT ActionT a) -> ActionT m a

MonadTrans ActionT

Defined in Web.Scotty.Internal.Types

Methods

lift :: Monad m => m a -> ActionT m a

MonadBaseControl b m => MonadBaseControl b (ActionT m)

Defined in Web.Scotty.Internal.Types

Associated Types

type StM (ActionT m) a

Methods

liftBaseWith :: (RunInBase (ActionT m) b -> b a) -> ActionT m a

restoreM :: StM (ActionT m) a -> ActionT m a

MonadUnliftIO m => MonadError StatusError (ActionT m)

Models the invariant that only StatusErrors can be thrown and caught.

Defined in Web.Scotty.Internal.Types

Methods

throwError :: StatusError -> ActionT m a

catchError :: ActionT m a -> (StatusError -> ActionT m a) -> ActionT m a

MonadReader r m => MonadReader r (ActionT m)

Defined in Web.Scotty.Internal.Types

Methods

ask :: ActionT m r

local :: (r -> r) -> ActionT m a -> ActionT m a

reader :: (r -> a) -> ActionT m a

MonadBase b m => MonadBase b (ActionT m)

Defined in Web.Scotty.Internal.Types

Methods

liftBase :: b α -> ActionT m α

MonadIO m => MonadFail (ActionT m)

Modeled after the behaviour in scotty < 0.20, fail throws a StatusError with code 500 ("Server Error"), which can be caught with catch.

Defined in Web.Scotty.Internal.Types

Methods

fail :: String -> ActionT m a

MonadIO m => MonadIO (ActionT m)

Defined in Web.Scotty.Internal.Types

Methods

liftIO :: IO a -> ActionT m a

MonadUnliftIO m => Alternative (ActionT m)

empty throws ActionError AENext, whereas (<|>) catches any ActionErrors or StatusErrors in the first action and proceeds to the second one.

Defined in Web.Scotty.Internal.Types

Methods

empty :: ActionT m a

(<|>) :: ActionT m a -> ActionT m a -> ActionT m a

some :: ActionT m a -> ActionT m [a]

many :: ActionT m a -> ActionT m [a]

Applicative m => Applicative (ActionT m)

Defined in Web.Scotty.Internal.Types

Methods

pure :: a -> ActionT m a

(<*>) :: ActionT m (a -> b) -> ActionT m a -> ActionT m b

liftA2 :: (a -> b -> c) -> ActionT m a -> ActionT m b -> ActionT m c

(*>) :: ActionT m a -> ActionT m b -> ActionT m b

(<*) :: ActionT m a -> ActionT m b -> ActionT m a

Functor m => Functor (ActionT m)

Defined in Web.Scotty.Internal.Types

Methods

fmap :: (a -> b) -> ActionT m a -> ActionT m b

(<$) :: a -> ActionT m b -> ActionT m a

Monad m => Monad (ActionT m)

Defined in Web.Scotty.Internal.Types

Methods

(>>=) :: ActionT m a -> (a -> ActionT m b) -> ActionT m b

(>>) :: ActionT m a -> ActionT m b -> ActionT m b

return :: a -> ActionT m a

MonadUnliftIO m => MonadPlus (ActionT m)

Defined in Web.Scotty.Internal.Types

Methods

mzero :: ActionT m a

mplus :: ActionT m a -> ActionT m a -> ActionT m a

MonadCatch m => MonadCatch (ActionT m)

Defined in Web.Scotty.Internal.Types

Methods

catch :: (HasCallStack, Exception e) => ActionT m a -> (e -> ActionT m a) -> ActionT m a

MonadThrow m => MonadThrow (ActionT m)

Defined in Web.Scotty.Internal.Types

Methods

throwM :: (HasCallStack, Exception e) => e -> ActionT m a

MonadUnliftIO m => MonadUnliftIO (ActionT m)

Defined in Web.Scotty.Internal.Types

Methods

withRunInIO :: ((forall a. ActionT m a -> IO a) -> IO b) -> ActionT m b

(Monad m, Monoid a) => Monoid (ActionT m a)

Defined in Web.Scotty.Internal.Types

Methods

mempty :: ActionT m a

mappend :: ActionT m a -> ActionT m a -> ActionT m a

mconcat :: [ActionT m a] -> ActionT m a

(Monad m, Semigroup a) => Semigroup (ActionT m a)

Defined in Web.Scotty.Internal.Types

Methods

(<>) :: ActionT m a -> ActionT m a -> ActionT m a

sconcat :: NonEmpty (ActionT m a) -> ActionT m a

stimes :: Integral b => b -> ActionT m a -> ActionT m a

type StT ActionT a

Defined in Web.Scotty.Internal.Types

type StT ActionT a = StT (ReaderT ActionEnv) a

type StM (ActionT m) a

Defined in Web.Scotty.Internal.Types

type StM (ActionT m) a = StM (ReaderT ActionEnv m) a

data ScottyState m

defaultScottyState :: ScottyState m