h*      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~0.22  Safe-Inferred%&71scottyType parameter t is the file content. Could be () when not needed or a FilePath for temp files instead.3scotty'Thrown e.g. when a request is too large>scottySpecializes a  to the  monad?scottyE.g. when a parameter is not found in a query string (400 Bad Request) or when parsing a JSON body fails (422 Unprocessable Entity)AscottyInternal exception mechanism used to modify the request processing flow.The exception constructor is not exposed to the user and all exceptions of this type are caught and processed within the  runAction function.BscottyRedirectCscotty3Stop processing this route and skip to the next oneDscottyStop processing the requestNscottyThe key part of having two MVars is that we can "clone" the BodyInfo to create a copy where the index is reset to 0, but the chunk cache is the same. Passing a cloned BodyInfo into each matched route allows them each to start from the first chunk if they call bodyReader.Introduced in (#308)Pscotty!index into the stream read so farRscotty can be called to get more chunksUscotty/whether we've reached the end of the stream yet_scotty#0 = silent, 1(def) = startup banner`scottyWarp 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.pscotty3The default response has code 200 OK and empty bodyrscotty&catches either ActionError (thrown by next), 35 (thrown if e.g. a query parameter is not found) or ? (via  raiseStatus)}scotty throws A C , whereas  catches any As or ?5s in the first action and proceeds to the second one.~scotty.Modeled after the behaviour in scotty < 0.20,  throws a ?: with code 500 ("Server Error"), which can be caught with .scottyModels the invariant that only ?s can be thrown and caught. !%$#"&'(0/.-,+*)123=<;:987654>?@ADCBEGFHMLJKINRQPOSVUTWXYZ\[]`_^abcdefghijklmnopqr]`_^aZ\[bYXWSVUTNRQPOHMLJKIcdefgEGFADCBh?@>3=<;:98765421(0/.-,+*)ijkl&'!%$#" mnopqr Safe-Inferredscottyreturn request body or throw a 3 if request body too bigscottybody chunk readerscotty max body size  Safe-Inferred"scottyMake a new BodyInfo with readProgress at 0 and an empty BodyChunkBuffer.scottyMake a copy of a BodyInfo, sharing the previous BodyChunkBuffer but with the readProgress MVar reset to 0.scotty/Get the form params and files from the request.NB : catches exceptions from warp% and 'wai-extra' and wraps them into 3scotty-Wrap exceptions from upstream libraries into 3scottyAdapted from wai-extra's Network.Wai.Parse, modified to accept body as list of Bytestrings. Reason: WAI's requestBody is an IO action that returns the body as chunks. Once read, they can't be read again. We read them into a lazy Bytestring, so Scotty user can get the raw body, even if they also want to call wai-extra's parsing routines.scottyRetrieve the entire body, using the cached chunks in the BodyInfo and reading any other chunks if they still exist. Mimic the previous behavior by throwing &= if the user has already started reading the body by chunks.throw 3 if request body too bigscottyRetrieve a chunk from the body at the index stored in the readProgress MVar. Serve the chunk from the cached array if it's already present; otherwise read another chunk from WAI and advance the index.scottyonly used for its body typescotty,the request body contents are read from here   Safe-Inferred"';E;scottyMinimum implemention: scottyTake a  value and parse it as a, or fail with a message.scotty4Default implementation parses comma-delimited lists. 7parseParamList t = mapM parseParam (T.split (== ',') t)scottyEvaluate a route, catch all exceptions (user-defined ones, internal and all remaining, in this order) and construct the  indicates route failed (due to Next) and pattern matching should try the next available route. ! indicates a successful response.scottyCatches ?+ and produces an appropriate HTTP response.scottyException handler in charge of A . Rethrowing Next here is caught by h. All other cases of A! are converted to HTTP responses.scotty*Default handler for exceptions from scottyscotty9Uncaught exceptions turn into HTTP 500 Server Error codesscottyThrow a "500 Server Error" ?, which can be caught with .1Uncaught exceptions turn into HTTP 500 responses.scottyThrow a ? exception that has an associated HTTP error code and can be caught with .Uncaught exceptions turn into HTTP responses corresponding to the given status.scottyThrow an exception which can be caught within the scope of the current Action with .If the exception is not caught locally, another option is to implement a global  (with defaultHandler) that defines its interpretation and a translation to HTTP error codes.1Uncaught exceptions turn into HTTP 500 responses.scottyAbort execution of this action and continue pattern matching routes. Like an exception, any code after  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 . 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: " <> wscottyCatch an exception e.g. a ? or a user-defined exception. ,raise JustKidding `catch` (\msg -> text msg)scotty#Catch any synchronous IO exceptionsscottyRedirect 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"scottyFinish 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.3scottyGet the  object.scottyGet list of uploaded files.3NB: Loads all file contents in memory with options scottyGet list of uploaded temp files and form parameters decoded from multipart payloads.:NB the temp files are deleted when the continuation exits.scotty6Get a request header. Header name is case-insensitive.scotty?Get all the request headers. Header names are case-insensitive.scottyGet the request body.7NB This loads the whole request body in memory at once.scotty'Get an IO action that reads body chunksThis is incompatible with  since  consumes all chunks.scotty6Parse 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  4https://www.restapitutorial.com/httpstatuscodes.html.NB : Internally this uses .scottyGet a parameter. First looks in captures, then form data, then query parameters.+Raises an exception which can be caught by  if parameter is not found.If parameter is found, but % fails to parse to the correct type,  is called. This means captures are somewhat typed, in that a route won't match if a correctly typed capture cannot be parsed.scotty Synonym for scottyLook up a path parameter.+Raises an exception which can be caught by  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 % fails to parse to the correct type,  is called. Since: 0.20scottyLook up a form parameter.+Raises an exception which can be caught by  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 $ fails to parse to the correct type. Since: 0.20scottyLook up a query parameter.+Raises an exception which can be caught by  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 $ fails to parse to the correct type. Since: 0.20scotty"Look up a path parameter. Returns  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  or  to signal something went wrong. Since: 0.21scotty%Look up a capture parameter. Returns  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  or  to signal something went wrong. Since: 0.21scotty"Look up a form parameter. Returns  if the parameter is not found or cannot be parsed at the right type.2NB : Doesn't throw exceptions, so developers must  or  to signal something went wrong. Since: 0.21scotty#Look up a query parameter. Returns  if the parameter is not found or cannot be parsed at the right type.2NB : Doesn't throw exceptions, so developers must  or  to signal something went wrong. Since: 0.21scottyLook up a parameter. Returns  if the parameter is not found or cannot be parsed at the right type.NB : Doesn't throw exceptions. Since: 0.21scotty=Get all parameters from path, form and query (in that order).scottyGet path parametersscottyGet path parametersscottyGet form parametersscottyGet query parametersscotty2Returns path and query parameters as a single listscottyAccess the HTTP  of the Response SINCE 0.21scotty'Access the HTTP headers of the Response SINCE 0.21scotty"Access the content of the Response SINCE 0.21scottyUseful for creating - instances for things that already implement . Ex: 3instance Parsable Int where parseParam = readEitherscottySet the HTTP response status.scotty?Add to the response headers. Header names are case-insensitive.scottySet one of the response headers. Will override any previously set value for that header. Header names are case-insensitive.scotty*Set the body of the response to the given  value. Also sets "Content-Type" header to "text/plain; charset=utf-8" if it has not already been set.scotty*Set the body of the response to the given  value. Also sets "Content-Type" header to "text/plain; charset=utf-8" if it has not already been set.scotty*Set the body of the response to the given  value. Also sets "Content-Type" header to "text/html; charset=utf-8" if it has not already been set.scotty*Set the body of the response to the given  value. Also sets "Content-Type" header to "text/html; charset=utf-8" if it has not already been set.scottySend a file as the response. Doesn't set the "Content-Type" header, so you probably want to do that on your own with . Setting a status code will have no effect because Warp will overwrite that to 200 (see  ).scottySet 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.scottySet 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 .scotty*Set the body of the response to the given  value. Doesn't set the "Content-Type" header, so you probably want to do that on your own with .scottyNest a whole WAI application inside a Scotty handler. See Web.Scotty for further documentationscotty>= S.text) in do withScotty server $ curl "http://localhost:3000/foo/something":} "something"scotty,Parse the request and construct the initial ( with a default 200 OK responsescottyMatch 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"scottyStandard 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.scottyBuild a route based on a function which can match using the entire  object. ' indicates the route does not match. A  value indicates a successful match, optionally returning a list of key-value pairs accessible by .:{let server = S.get (function $ \req -> Just [("version", T.pack $ show $ W.httpVersion req)]) $ do* v <- S.pathParam "version" S.text v in do7 withScotty server $ curl "http://localhost:3000/":} "HTTP/1.1"scottyBuild a route that requires the requested path match exactly, without captures.  Safe-Inferred"NEscottyRun a scotty application using the warp server. NB: scotty p === scottyT p idscottyRun a scotty application using the warp server, passing extra options. NB: scottyOpts opts === scottyOptsT opts idscottyRun a scotty application using the warp server, passing extra options, and listening on the provided socket. NB: scottySocket opts sock === scottySocketT opts sock idscotty%Turn a scotty application into a WAI W, which can be run with any WAI handler. NB: scottyApp === scottyAppT idscottyException handler in charge of 3 that's not caught by scottyExceptionHandlerscotty+Global handler for user-defined exceptions.scottyUse 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.scottySet 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.scotty Run monad m into , called at each action.scotty Run monad m into , called at each action.scotty Run monad m into , called at each action.scottyRequest size limit]^_`a?@3456789:;<=21!"#$%Y>EHc]^_`a?@3456789:;<=21!"#$%Y>EHc Safe-InferredO]^_`a?@3456789:;<=21!"#$%Y>EHc]^_`a?@3456789:;<=21!"#$%Y>EHc Safe-Inferred"z?scotty/Run a scotty application using the warp server.scottyRun a scotty application using the warp server, passing extra options.scottyRun a scotty application using the warp server, passing extra options, and listening on the provided socket. This allows the user to provide, for example, a Unix named socket, which can be used when reverse HTTP proxying into your application.scotty%Turn a scotty application into a WAI ), which can be run with any WAI handler.scotty+Global handler for user-defined exceptions.scottyUse 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.scottyNest a whole WAI application inside a Scotty handler. Note: You will want to ensure that this route fully handles the response, as there is no easy delegation as per normal Scotty actions. Also, you will have to carefully ensure that you are expecting the correct routes, this could require stripping the current prefix, or adding the prefix to your application's handlers if it depends on them. One potential use-case for this is hosting a web-socket handler under a specific route.scottySet 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.scottyThrow a "500 Server Error" ?, which can be caught with .1Uncaught exceptions turn into HTTP 500 responses.scottyThrow a ? exception that has an associated HTTP error code and can be caught with .Uncaught exceptions turn into HTTP responses corresponding to the given status.scottyThrow an exception which can be caught within the scope of the current Action with .If the exception is not caught locally, another option is to implement a global  (with ) that defines its interpretation and a translation to HTTP error codes.1Uncaught exceptions turn into HTTP 500 responses.scottyAbort execution of this action and continue pattern matching routes. Like an exception, any code after  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 . 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: " <> wscottyAbort execution of this action. Like an exception, any code after  is not executed.As an example only requests to  /foo/special8 will include in the response content the text message. get "/foo/:bar" $ do w :: Text <- pathParam "bar" unless (w == "special") finish text "You made a request to /foo/special" Since: 0.10.3scottyCatch an exception e.g. a ? or a user-defined exception. ,raise JustKidding `catch` (\msg -> text msg)scottyLike , but catch any IO exceptions and turn them into Scotty exceptions.scottyRedirect 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"scottyGet the  object.scottyGet list of uploaded files.3NB: Loads all file contents in memory with options scottyGet list of temp files and form parameters decoded from multipart payloads.9NB the temp files are deleted when the continuation exitsscotty6Get a request header. Header name is case-insensitive.scotty?Get all the request headers. Header names are case-insensitive.scottyGet the request body.+NB: loads the entire request body in memoryscotty'Get an IO action that reads body chunksThis is incompatible with  since  consumes all chunks.scottyParse the request body as a JSON object and return it. Raises an exception if parse is unsuccessful. NB: uses  internallyscottyGet a parameter. First looks in captures, then form data, then query parameters.+Raises an exception which can be caught by  if parameter is not found.If parameter is found, but  parseParam% fails to parse to the correct type,  is called. This means captures are somewhat typed, in that a route won't match if a correctly typed capture cannot be parsed.scotty Synonym for  Since: 0.20scottyGet a path parameter.+Raises an exception which can be caught by  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,  is called. Since: 0.21scottyGet a form parameter.+Raises an exception which can be caught by  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.20scottyGet a query parameter.+Raises an exception which can be caught by  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.20scotty"Look up a path parameter. Returns  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  or  to signal something went wrong. Since: 0.21scotty Synonym for  Since: 0.21scotty"Look up a form parameter. Returns  if the parameter is not found or cannot be parsed at the right type.2NB : Doesn't throw exceptions, so developers must  or  to signal something went wrong. Since: 0.21scotty#Look up a query parameter. Returns  if the parameter is not found or cannot be parsed at the right type.2NB : Doesn't throw exceptions, so developers must  or  to signal something went wrong. Since: 0.21scotty=Get all parameters from path, form and query (in that order).scotty Synonym for scottyGet path parametersscottyGet form parametersscottyGet query parametersscotty-Set the HTTP response status. Default is 200.scotty?Add to the response headers. Header names are case-insensitive.scottySet one of the response headers. Will override any previously set value for that header. Header names are case-insensitive.scotty*Set the body of the response to the given  value. Also sets "Content-Type" header to "text/plain; charset=utf-8" if it has not already been set.scotty*Set the body of the response to the given  value. Also sets "Content-Type" header to "text/html; charset=utf-8" if it has not already been set.scottySend a file as the response. Doesn't set the "Content-Type" header, so you probably want to do that on your own with .scottySet 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.scottySet the body of the response to a StreamingBody. Doesn't set the "Content-Type" header, so you probably want to do that on your own with .scotty*Set the body of the response to the given  value. Doesn't set the "Content-Type" header, so you probably want to do that on your own with .scottyAccess the HTTP  of the Response Since: 0.21scotty'Access the HTTP headers of the Response Since: 0.21scotty"Access the content of the Response Since: 0.21scottyget =  GETscottypost =  POSTscottyput =  PUTscotty delete =  DELETEscottypatch =  PATCHscotty options =  OPTIONSscotty5Add a route that matches regardless of the HTTP verb.scottySpecify an action to take if nothing else is found. Note: this _always_ matches, so should generally be the last route specified.scottyDefine a route with a 5, 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 captures2. These are parameters that can be looked up with .:{=let server = S.get "/foo/:bar" (S.pathParam "bar" >>= S.text) in do withScotty server $ curl "http://localhost:3000/foo/something":} "something"scottyMatch 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"scottyStandard 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.scottyBuild a route based on a function which can match using the entire  object. ' indicates the route does not match. A  value indicates a successful match, optionally returning a list of key-value pairs accessible by .:{let server = S.get (function $ \req -> Just [("version", T.pack $ show $ W.httpVersion req)]) $ do* v <- S.pathParam "version" S.text v in do7 withScotty server $ curl "http://localhost:3000/":} "HTTP/1.1"scottyBuild a route that requires the requested path match exactly, without captures.scotty"temp files validation, storage etc]^_`a?@3456789:;<=21!"#$%Y>Hc]^_`a?@3456789:;<=21!"#$%Y>Hc?(c) 2014, 2015 Mrti Mas, (c) 2023 Marco Zocca BSD-3-Clause experimentalGHC Safe-Inferred"Lscotty3Set a cookie, with full access to its options (see )scotty and  combined.scottyLookup one cookie namescottyReturns all cookiesscottyBrowsers don't directly delete a cookie, but setting its expiry to a past date (e.g. the UNIX epoch) ensures that the cookie will be invalidated (whether and when it will be actually deleted by the browser seems to be browser-dependent).scottyConstruct a simple cookie (an UTF-8 string pair with default cookie options)scottynamescottyvaluescottynamescottynamescottynamescottyvalue       !"#$%&'%&'()*+,-./01223456789:;<=>>?@ABCDEFGHIJKLMNOPQRSTUVVWXYZ[[\]]^_`abbcdeffghijkllmnnopqrstuvwxyz{|}~                                                                       *+,+,+,+,+,+,     +,        i"scotty-0.22-LOQDLh9o06y3W6KZlPh3KZWeb.Scotty.TransWeb.Scotty.CookieWeb.Scotty.Internal.TypesWeb.Scotty.Trans.Strict Web.ScottyscottyWeb.Scotty.UtilWeb.Scotty.BodyWeb.Scotty.Action!Network.Wai.Handler.Warp.Internal sendResponseWeb.Scotty.Trans.LazyWeb.Scotty.RouteBL ByteStringbaseControl.Monad.IO.ClassliftIO#cookie-0.5.0-EjzPmdLI5vNIjBFo1G5pB1 Web.CookieSameSiteOption SetCookie setCookieNamesetCookieValue setCookiePathsetCookieExpiressetCookieMaxAgesetCookieDomainsetCookieHttpOnlysetCookieSecuresetCookieSameSite CookiesText sameSiteLaxsameSiteStrict sameSiteNonedefaultSetCookieexceptions-0.10.7Control.Monad.CatchHandler(unliftio-0.2.25.0-40dfGWPP97w9btUo1Ouu28UnliftIO.Exceptioncatch'wai-extra-3.1.14-1jRqHPFbAcAKDyU7Onpld5Network.Wai.ParseParseRequestBodyOptions RoutePatternCaptureLiteralFunctionActionTrunAMScottyResponseSRsrStatus srHeaders srContentContentContentBuilder ContentFile ContentStreamContentResponseBodyPartiallyStreamed ActionEnvEnvenvReq envPathParamsenvQueryParamsenvFormDataActionenvBody envBodyChunk envResponseFileParamScottyExceptionRequestTooLarge MalformedJSONFailedToParseJSONPathParameterNotFoundQueryParameterNotFoundFormFieldNotFoundFailedToParseParameterWarpRequestExceptionWaiRequestParseExceptionResourceTException ErrorHandler StatusError ActionError AERedirectAENextAEFinishScottyTrunS ScottyState middlewaresrouteshandler routeOptionsBodyInfobodyInfoReadProgressbodyInfoChunkBufferbodyInfoDirectChunkReadBodyChunkBufferhasFinishedReadingChunkschunksReadSoFar Application Middleware Kilobytes RouteOptionsmaxRequestBodySizeOptionsverbosesettingsdefaultOptionsdefaultRouteOptionsdefaultScottyState addMiddlewareaddRoute setHandlerupdateMaxRequestBodySizetryNextformParamsAndFilesWith getResponsegetResponseActionmodifyResponse setContent setHeaderWith setStatusdefaultScottyResponse withActionEnv tryAnyStatus$fDefaultOptions$fDefaultRouteOptions$fExceptionActionError$fExceptionStatusError$fExceptionScottyException $fExceptionBodyPartiallyStreamed$fDefaultScottyResponse$fMonoidActionT$fSemigroupActionT$fMonadPlusActionT$fAlternativeActionT$fMonadFailActionT$fMonadErrorStatusErrorActionT$fMonadReaderrActionT$fMonoidScottyT$fSemigroupScottyT$fIsStringRoutePattern$fFunctorScottyT$fApplicativeScottyT$fMonadScottyT$fFunctorActionT$fApplicativeActionT$fMonadActionT$fMonadIOActionT$fMonadTransActionT$fMonadThrowActionT$fMonadCatchActionT$fMonadBasebActionT$fMonadBaseControlbActionT$fMonadTransControlActionT$fMonadUnliftIOActionT$fShowBodyPartiallyStreamed$fShowScottyException$fShowStatusError$fShowActionErrorParsable parseParamparseParamListraise raiseStatusthrownextrescueliftAndCatchIOredirectfinishrequestfiles filesOptsheaderheadersbody bodyReaderjsonDataparam captureParam pathParam formParam queryParampathParamMaybecaptureParamMaybeformParamMaybequeryParamMaybeparams pathParams captureParams formParams queryParamsgetResponseStatusgetResponseHeadersgetResponseContent readEitherstatus addHeader setHeadertexttextLazyhtmlhtmlLazyfilejsonstreamrawnestedgetpostputdeletepatchoptionsmatchAnynotFoundaddrouteregexcapturefunctionliteralscottyT scottyOptsT scottySocketT scottyAppTdefaultHandler middlewaresetMaxRequestBodySizeActionMScottyM scottyOpts scottySocket scottyApp setCookiesetSimpleCookie getCookie getCookies deleteCookiemakeSimpleCookieGHC.Baseempty<|>Control.Monad.FailfailGHC.IOreadRequestBodylazyTextToStrictByteStringstrictByteStringToLazyText text-2.0.2Data.Text.EncodingdecodeUtf8Lenient mkResponsereplaceaddaddIfNotPresentsocketDescription newBodyInfo cloneBodyInfogetFormParamsAndFilesActionhandleWaiParseSafeExceptionsparseRequestBodyExBS getBodyActiongetBodyChunkActionRequestParseExceptionMaxParamSizeExceededParamNameTooLongMaxFileNumberExceededFilenameTooLongTooManyHeaderLinesData.Text.InternalText runAction wai-3.2.4-9Rvl8IwZnPnCdzFsZVqO4CNetwork.Wai.InternalResponse GHC.MaybeNothingJuststatusErrorHandleractionErrorHandlerscottyExceptionHandlersomeExceptionHandlerRequestdefaultParseRequestBodyOptionsparamWithMaybe getParams'http-types-0.12.4-7ravU9ZeEhYD9G3h69uf3Network.HTTP.Types.StatusStatusGHC.ReadReadbytestring-0.11.5.2Data.ByteString.Lazy.Internal$fParsableUTCTime $fParsable()$fParsableChar paramWith rawResponseNetwork.HTTP.Types.MethodGETPOSTPUTDELETEPATCHOPTIONS StdMethodmkEnvunhandledExceptionHandlerghc-prim GHC.TypesIO Network.WaiData.Text.Internal.Lazy