yesod-core-1.4.23.1: Creation of type-safe, RESTful web applications.

Safe HaskellNone
LanguageHaskell98

Yesod.Core

Contents

Synopsis

Type classes

class RenderRoute site => Yesod site where Source #

Define settings for a Yesod applications. All methods have intelligent defaults, and therefore no implementation is required.

Methods

approot :: Approot site Source #

An absolute URL to the root of the application. Do not include trailing slash.

Default value: ApprootRelative. This is valid under the following conditions:

  • Your application is served from the root of the domain.
  • You do not use any features that require absolute URLs, such as Atom feeds and XML sitemaps.

If this is not true, you should override with a different implementation.

errorHandler :: ErrorResponse -> HandlerT site IO TypedContent Source #

Output error response pages.

Default value: defaultErrorHandler.

defaultLayout :: WidgetT site IO () -> HandlerT site IO Html Source #

Applies some form of layout to the contents of a page.

urlRenderOverride :: site -> Route site -> Maybe Builder Source #

Deprecated: Use urlParamRenderOverride instead

Override the rendering function for a particular URL. One use case for this is to offload static hosting to a different domain name to avoid sending cookies.

urlParamRenderOverride :: site -> Route site -> [(Text, Text)] -> Maybe Builder Source #

Override the rendering function for a particular URL and query string parameters. One use case for this is to offload static hosting to a different domain name to avoid sending cookies.

For backward compatibility default implementation is in terms of urlRenderOverride, probably ineffective

Since 1.4.23

isAuthorized :: Route site -> Bool -> HandlerT site IO AuthResult Source #

Determine if a request is authorized or not.

Return Authorized if the request is authorized, Unauthorized a message if unauthorized. If authentication is required, return AuthenticationRequired.

isWriteRequest :: Route site -> HandlerT site IO Bool Source #

Determines whether the current request is a write request. By default, this assumes you are following RESTful principles, and determines this from request method. In particular, all except the following request methods are considered write: GET HEAD OPTIONS TRACE.

This function is used to determine if a request is authorized; see isAuthorized.

authRoute :: site -> Maybe (Route site) Source #

The default route for authentication.

Used in particular by isAuthorized, but library users can do whatever they want with it.

cleanPath :: site -> [Text] -> Either [Text] [Text] Source #

A function used to clean up path segments. It returns Right with a clean path or Left with a new set of pieces the user should be redirected to. The default implementation enforces:

  • No double slashes
  • There is no trailing slash.

Note that versions of Yesod prior to 0.7 used a different set of rules involing trailing slashes.

joinPath :: site -> Text -> [Text] -> [(Text, Text)] -> Builder Source #

Builds an absolute URL by concatenating the application root with the pieces of a path and a query string, if any. Note that the pieces of the path have been previously cleaned up by cleanPath.

addStaticContent :: Text -> Text -> ByteString -> HandlerT site IO (Maybe (Either Text (Route site, [(Text, Text)]))) Source #

This function is used to store some static content to be served as an external file. The most common case of this is stashing CSS and JavaScript content in an external file; the Yesod.Widget module uses this feature.

The return value is Nothing if no storing was performed; this is the default implementation. A Just Left gives the absolute URL of the file, whereas a Just Right gives the type-safe URL. The former is necessary when you are serving the content outside the context of a Yesod application, such as via memcached.

maximumContentLength :: site -> Maybe (Route site) -> Maybe Word64 Source #

Maximum allowed length of the request body, in bytes.

If Nothing, no maximum is applied.

Default: 2 megabytes.

makeLogger :: site -> IO Logger Source #

Creates a Logger to use for log messages.

Note that a common technique (endorsed by the scaffolding) is to create a Logger value and place it in your foundation datatype, and have this method return that already created value. That way, you can use that same Logger for printing messages during app initialization.

Default: the defaultMakeLogger function.

messageLoggerSource :: site -> Logger -> Loc -> LogSource -> LogLevel -> LogStr -> IO () Source #

Send a message to the Logger provided by getLogger.

Default: the defaultMessageLoggerSource function, using shouldLogIO to check whether we should log.

jsLoader :: site -> ScriptLoadPosition site Source #

Where to Load sripts from. We recommend the default value, BottomOfBody.

makeSessionBackend :: site -> IO (Maybe SessionBackend) Source #

Create a session backend. Returning Nothing disables sessions. If you'd like to change the way that the session cookies are created, take a look at customizeSessionCookies.

Default: Uses clientsession with a 2 hour timeout.

fileUpload :: site -> RequestBodyLength -> FileUpload Source #

How to store uploaded files.

Default: When the request body is greater than 50kb, store in a temp file. For chunked request bodies, store in a temp file. Otherwise, store in memory.

shouldLog :: site -> LogSource -> LogLevel -> Bool Source #

Should we log the given log source/level combination.

Default: the defaultShouldLog function.

shouldLogIO :: site -> LogSource -> LogLevel -> IO Bool Source #

Should we log the given log source/level combination.

Note that this is almost identical to shouldLog, except the result lives in IO. This allows you to dynamically alter the logging level of your application by having this result depend on, e.g., an IORef.

The default implementation simply uses shouldLog. Future versions of Yesod will remove shouldLog and use this method exclusively.

Since 1.2.4

yesodMiddleware :: ToTypedContent res => HandlerT site IO res -> HandlerT site IO res Source #

A Yesod middleware, which will wrap every handler function. This allows you to run code before and after a normal handler.

Default: the defaultYesodMiddleware function.

Since: 1.1.6

yesodWithInternalState :: site -> Maybe (Route site) -> (InternalState -> IO a) -> IO a Source #

How to allocate an InternalState for each request.

The default implementation is almost always what you want. However, if you know that you are never taking advantage of the MonadResource instance in your handler functions, setting this to a dummy implementation can provide a small optimization. Only do this if you really know what you're doing, otherwise you can turn safe code into a runtime error!

Since 1.4.2

Instances

Yesod LiteApp Source # 

Methods

approot :: Approot LiteApp Source #

errorHandler :: ErrorResponse -> HandlerT LiteApp IO TypedContent Source #

defaultLayout :: WidgetT LiteApp IO () -> HandlerT LiteApp IO Html Source #

urlRenderOverride :: LiteApp -> Route LiteApp -> Maybe Builder Source #

urlParamRenderOverride :: LiteApp -> Route LiteApp -> [(Text, Text)] -> Maybe Builder Source #

isAuthorized :: Route LiteApp -> Bool -> HandlerT LiteApp IO AuthResult Source #

isWriteRequest :: Route LiteApp -> HandlerT LiteApp IO Bool Source #

authRoute :: LiteApp -> Maybe (Route LiteApp) Source #

cleanPath :: LiteApp -> [Text] -> Either [Text] [Text] Source #

joinPath :: LiteApp -> Text -> [Text] -> [(Text, Text)] -> Builder Source #

addStaticContent :: Text -> Text -> ByteString -> HandlerT LiteApp IO (Maybe (Either Text (Route LiteApp, [(Text, Text)]))) Source #

maximumContentLength :: LiteApp -> Maybe (Route LiteApp) -> Maybe Word64 Source #

makeLogger :: LiteApp -> IO Logger Source #

messageLoggerSource :: LiteApp -> Logger -> Loc -> LogSource -> LogLevel -> LogStr -> IO () Source #

jsLoader :: LiteApp -> ScriptLoadPosition LiteApp Source #

makeSessionBackend :: LiteApp -> IO (Maybe SessionBackend) Source #

fileUpload :: LiteApp -> RequestBodyLength -> FileUpload Source #

shouldLog :: LiteApp -> LogSource -> LogLevel -> Bool Source #

shouldLogIO :: LiteApp -> LogSource -> LogLevel -> IO Bool Source #

yesodMiddleware :: ToTypedContent res => HandlerT LiteApp IO res -> HandlerT LiteApp IO res Source #

yesodWithInternalState :: LiteApp -> Maybe (Route LiteApp) -> (InternalState -> IO a) -> IO a Source #

class Yesod site => YesodDispatch site where Source #

This class is automatically instantiated when you use the template haskell mkYesod function. You should never need to deal with it directly.

Minimal complete definition

yesodDispatch

class Eq (Route a) => RenderRoute a where Source #

Minimal complete definition

renderRoute

Associated Types

data Route a Source #

The type-safe URLs associated with a site argument.

Methods

renderRoute :: Route a -> ([Text], [(Text, Text)]) Source #

Instances

RenderRoute WaiSubsite Source # 

Associated Types

data Route WaiSubsite :: * Source #

Methods

renderRoute :: Route WaiSubsite -> ([Text], [(Text, Text)]) Source #

RenderRoute LiteApp Source # 

Associated Types

data Route LiteApp :: * Source #

Methods

renderRoute :: Route LiteApp -> ([Text], [(Text, Text)]) Source #

class RenderRoute a => ParseRoute a where Source #

Minimal complete definition

parseRoute

Methods

parseRoute :: ([Text], [(Text, Text)]) -> Maybe (Route a) Source #

class RenderRoute a => RouteAttrs a where Source #

Minimal complete definition

routeAttrs

Methods

routeAttrs :: Route a -> Set Text Source #

Breadcrumbs

class YesodBreadcrumbs site where Source #

A type-safe, concise method of creating breadcrumbs for pages. For each resource, you declare the title of the page and the parent resource (if present).

Minimal complete definition

breadcrumb

Methods

breadcrumb :: Route site -> HandlerT site IO (Text, Maybe (Route site)) Source #

Returns the title and the parent resource, if available. If you return a Nothing, then this is considered a top-level page.

breadcrumbs :: YesodBreadcrumbs site => HandlerT site IO (Text, [(Route site, Text)]) Source #

Gets the title of the current page and the hierarchy of parent pages, along with their respective titles.

Types

data Approot master Source #

How to determine the root of the application for constructing URLs.

Note that future versions of Yesod may add new constructors without bumping the major version number. As a result, you should not pattern match on Approot values.

Constructors

ApprootRelative

No application root.

ApprootStatic !Text 
ApprootMaster !(master -> Text) 
ApprootRequest !(master -> Request -> Text) 

data ErrorResponse Source #

Responses to indicate some form of an error occurred.

Utitlities

maybeAuthorized Source #

Arguments

:: Yesod site 
=> Route site 
-> Bool

is this a write request?

-> HandlerT site IO (Maybe (Route site)) 

Return the same URL if the user is authorized to see it.

Built on top of isAuthorized. This is useful for building page that only contain links to pages the user is allowed to see.

widgetToPageContent :: (Eq (Route site), Yesod site) => WidgetT site IO () -> HandlerT site IO (PageContent (Route site)) Source #

Convert a widget to a PageContent.

Defaults

defaultErrorHandler :: Yesod site => ErrorResponse -> HandlerT site IO TypedContent Source #

The default error handler for errorHandler.

defaultYesodMiddleware :: Yesod site => HandlerT site IO res -> HandlerT site IO res Source #

Default implementation of yesodMiddleware. Adds the response header "Vary: Accept, Accept-Language" and performs authorization checks.

Since 1.2.0

authorizationCheck :: Yesod site => HandlerT site IO () Source #

Check if a given request is authorized via isAuthorized and isWriteRequest.

Since 1.2.0

Data types

unauthorizedI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => msg -> m AuthResult Source #

Return an Unauthorized value, with the given i18n message.

Logging

defaultMakeLogger :: IO Logger Source #

Default implementation of makeLogger. Sends to stdout and automatically flushes on each write.

Since 1.4.10

defaultMessageLoggerSource Source #

Arguments

:: (LogSource -> LogLevel -> IO Bool)

Check whether we should log this

-> Logger 
-> Loc

position in source code

-> LogSource 
-> LogLevel 
-> LogStr

message

-> IO () 

Default implementation of messageLoggerSource. Checks if the message should be logged using the provided function, and if so, formats using formatLogMessage. You can use defaultShouldLogIO as the provided function.

Since 1.4.10

defaultShouldLog :: LogSource -> LogLevel -> Bool Source #

Default implementation of shouldLog. Logs everything at or above LevelInfo.

Since 1.4.10

defaultShouldLogIO :: LogSource -> LogLevel -> IO Bool Source #

A default implementation of shouldLogIO that can be used with defaultMessageLoggerSource. Just uses defaultShouldLog.

Since 1.4.10

formatLogMessage Source #

Arguments

:: IO ZonedDate 
-> Loc 
-> LogSource 
-> LogLevel 
-> LogStr

message

-> IO LogStr 

Default formatting for log messages. When you use the template haskell logging functions for to log with information about the source location, that information will be appended to the end of the log. When you use the non-TH logging functions, like logDebugN, this function does not include source information. This currently works by checking to see if the package name is the string "<unknown>". This is a hack, but it removes some of the visual clutter from non-TH logs.

Since 1.4.10

logDebug :: Q Exp #

Generates a function that takes a Text and logs a LevelDebug message. Usage:

$(logDebug) "This is a debug log message"

logOther :: Text -> Q Exp #

Generates a function that takes a Text and logs a LevelOther message. Usage:

$(logOther "My new level") "This is a log message"

logDebugS :: Q Exp #

Generates a function that takes a LogSource and Text and logs a LevelDebug message. Usage:

$logDebugS "SomeSource" "This is a debug log message"

logOtherS :: Q Exp #

Generates a function that takes a LogSource, a level name and a Text and logs a LevelOther message. Usage:

$logOtherS "SomeSource" "My new level" "This is a log message"

Sessions

newtype SessionBackend Source #

Constructors

SessionBackend 

Fields

customizeSessionCookies :: (SetCookie -> SetCookie) -> SessionBackend -> SessionBackend Source #

Customize the cookies used by the session backend. You may use this function on your definition of makeSessionBackend.

For example, you could set the cookie domain so that it would work across many subdomains:

makeSessionBackend site =
    (fmap . fmap) (customizeSessionCookies addDomain) ...
  where
    addDomain cookie = cookie { setCookieDomain = Just ".example.com" }

Default: Do not customize anything (id).

envClientSessionBackend Source #

Arguments

:: Int

minutes

-> String

environment variable name

-> IO SessionBackend 

Create a SessionBackend which reads the session key from the named environment variable.

This can be useful if:

  1. You can't rely on a persistent file system (e.g. Heroku)
  2. Your application is open source (e.g. you can't commit the key)

By keeping a consistent value in the environment variable, your users will have consistent sessions without relying on the file system.

Note: A suitable value should only be obtained in one of two ways:

  1. Run this code without the variable set, a value will be generated and printed on devstdout/
  2. Use clientsession-generate

Since 1.4.5

sslOnlySessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend) Source #

Defends against session hijacking by setting the secure bit on session cookies so that browsers will not transmit them over http. With this setting on, it follows that the server will regard requests made over http as sessionless, because the session cookie will not be included in the request. Use this as part of a total security measure which also includes disabling HTTP traffic to the site or issuing redirects from HTTP urls, and composing sslOnlyMiddleware with the site's yesodMiddleware.

Since 1.4.7

laxSameSiteSessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend) Source #

Helps defend against CSRF attacks by setting the SameSite attribute on session cookies to Lax. With the Lax setting, the cookie will be sent with same-site requests, and with cross-site top-level navigations.

This option is liable to change in future versions of Yesod as the spec evolves. View more information here.

Since: 1.4.23

strictSameSiteSessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend) Source #

Helps defend against CSRF attacks by setting the SameSite attribute on session cookies to Strict. With the Strict setting, the cookie will only be sent with same-site requests.

This option is liable to change in future versions of Yesod as the spec evolves. View more information here.

Since: 1.4.23

sslOnlyMiddleware Source #

Arguments

:: Yesod site 
=> Int

minutes

-> HandlerT site IO res 
-> HandlerT site IO res 

Apply a Strict-Transport-Security header with the specified timeout to all responses so that browsers will rewrite all http links to https until the timeout expires. For security, the max-age of the STS header should always equal or exceed the client sessions timeout. This defends against SSL-stripping man-in-the-middle attacks. It is only effective if a secure connection has already been made; Strict-Transport-Security headers are ignored over HTTP.

Since 1.4.7

clientSessionDateCacher Source #

Arguments

:: NominalDiffTime

Inactive session validity.

-> IO (IO ClientSessionDateCache, IO ()) 

data Header Source #

Headers to be added to a Result.

Instances

CSRF protection

defaultCsrfMiddleware :: Yesod site => HandlerT site IO res -> HandlerT site IO res Source #

Calls defaultCsrfSetCookieMiddleware and defaultCsrfCheckMiddleware.

For details, see the "AJAX CSRF protection" section of Yesod.Core.Handler.

You can add this chain this middleware together with other middleware like so:

yesodMiddleware = defaultYesodMiddleware . defaultCsrfMiddleware

or:

yesodMiddleware app = defaultYesodMiddleware $ defaultCsrfMiddleware $ app

Since 1.4.14

defaultCsrfSetCookieMiddleware :: Yesod site => HandlerT site IO res -> HandlerT site IO res Source #

Calls csrfSetCookieMiddleware with the defaultCsrfCookieName.

The cookie's path is set to /, making it valid for your whole website.

Since 1.4.14

csrfSetCookieMiddleware :: Yesod site => HandlerT site IO res -> SetCookie -> HandlerT site IO res Source #

Takes a SetCookie and overrides its value with a CSRF token, then sets the cookie. See setCsrfCookieWithCookie.

For details, see the "AJAX CSRF protection" section of Yesod.Core.Handler.

Make sure to set the setCookiePath to the root path of your application, otherwise you'll generate a new CSRF token for every path of your app. If your app is run from from e.g. www.example.com/app1, use app1. The vast majority of sites will just use /.

Since 1.4.14

csrfCheckMiddleware Source #

Arguments

:: Yesod site 
=> HandlerT site IO res 
-> HandlerT site IO Bool

Whether or not to perform the CSRF check.

-> CI ByteString

The header name to lookup the CSRF token from.

-> Text

The POST parameter name to lookup the CSRF token from.

-> HandlerT site IO res 

Looks up the CSRF token from the request headers or POST parameters. If the value doesn't match the token stored in the session, this function throws a PermissionDenied error.

For details, see the "AJAX CSRF protection" section of Yesod.Core.Handler.

Since 1.4.14

JS loaders

type BottomOfHeadAsync master Source #

Arguments

 = [Text]

urls to load asynchronously

-> Maybe (HtmlUrl (Route master))

widget of js to run on async completion

-> HtmlUrl (Route master)

widget to insert at the bottom of head

Subsites

class MonadResource m => MonadHandler m where Source #

Minimal complete definition

liftHandlerT

Associated Types

type HandlerSite m Source #

Methods

liftHandlerT :: HandlerT (HandlerSite m) IO a -> m a Source #

Instances

MonadHandler m => MonadHandler (MaybeT m) Source # 

Associated Types

type HandlerSite (MaybeT m :: * -> *) :: * Source #

MonadHandler m => MonadHandler (ListT m) Source # 

Associated Types

type HandlerSite (ListT m :: * -> *) :: * Source #

(Monoid w, MonadHandler m) => MonadHandler (WriterT w m) Source # 

Associated Types

type HandlerSite (WriterT w m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (WriterT w m)) IO a -> WriterT w m a Source #

(Monoid w, MonadHandler m) => MonadHandler (WriterT w m) Source # 

Associated Types

type HandlerSite (WriterT w m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (WriterT w m)) IO a -> WriterT w m a Source #

MonadHandler m => MonadHandler (StateT s m) Source # 

Associated Types

type HandlerSite (StateT s m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (StateT s m)) IO a -> StateT s m a Source #

MonadHandler m => MonadHandler (StateT s m) Source # 

Associated Types

type HandlerSite (StateT s m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (StateT s m)) IO a -> StateT s m a Source #

(Error e, MonadHandler m) => MonadHandler (ErrorT e m) Source # 

Associated Types

type HandlerSite (ErrorT e m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (ErrorT e m)) IO a -> ErrorT e m a Source #

MonadHandler m => MonadHandler (IdentityT * m) Source # 

Associated Types

type HandlerSite (IdentityT * m :: * -> *) :: * Source #

MonadResourceBase m => MonadHandler (WidgetT site m) Source # 

Associated Types

type HandlerSite (WidgetT site m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (WidgetT site m)) IO a -> WidgetT site m a Source #

MonadResourceBase m => MonadHandler (HandlerT site m) Source # 

Associated Types

type HandlerSite (HandlerT site m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (HandlerT site m)) IO a -> HandlerT site m a Source #

MonadHandler m => MonadHandler (ReaderT * r m) Source # 

Associated Types

type HandlerSite (ReaderT * r m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (ReaderT * r m)) IO a -> ReaderT * r m a Source #

MonadHandler m => MonadHandler (ConduitM i o m) Source # 

Associated Types

type HandlerSite (ConduitM i o m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (ConduitM i o m)) IO a -> ConduitM i o m a Source #

(Monoid w, MonadHandler m) => MonadHandler (RWST r w s m) Source # 

Associated Types

type HandlerSite (RWST r w s m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (RWST r w s m)) IO a -> RWST r w s m a Source #

(Monoid w, MonadHandler m) => MonadHandler (RWST r w s m) Source # 

Associated Types

type HandlerSite (RWST r w s m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (RWST r w s m)) IO a -> RWST r w s m a Source #

MonadHandler m => MonadHandler (Pipe l i o u m) Source # 

Associated Types

type HandlerSite (Pipe l i o u m :: * -> *) :: * Source #

Methods

liftHandlerT :: HandlerT (HandlerSite (Pipe l i o u m)) IO a -> Pipe l i o u m a Source #

class MonadHandler m => MonadWidget m where Source #

Minimal complete definition

liftWidgetT

Methods

liftWidgetT :: WidgetT (HandlerSite m) IO a -> m a Source #

Instances

MonadWidget m => MonadWidget (MaybeT m) Source # 
MonadWidget m => MonadWidget (ListT m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (ListT m)) IO a -> ListT m a Source #

(Monoid w, MonadWidget m) => MonadWidget (WriterT w m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (WriterT w m)) IO a -> WriterT w m a Source #

(Monoid w, MonadWidget m) => MonadWidget (WriterT w m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (WriterT w m)) IO a -> WriterT w m a Source #

MonadWidget m => MonadWidget (StateT s m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (StateT s m)) IO a -> StateT s m a Source #

MonadWidget m => MonadWidget (StateT s m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (StateT s m)) IO a -> StateT s m a Source #

(Error e, MonadWidget m) => MonadWidget (ErrorT e m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (ErrorT e m)) IO a -> ErrorT e m a Source #

MonadWidget m => MonadWidget (IdentityT * m) Source # 
MonadResourceBase m => MonadWidget (WidgetT site m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (WidgetT site m)) IO a -> WidgetT site m a Source #

MonadWidget m => MonadWidget (ReaderT * r m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (ReaderT * r m)) IO a -> ReaderT * r m a Source #

MonadWidget m => MonadWidget (ConduitM i o m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (ConduitM i o m)) IO a -> ConduitM i o m a Source #

(Monoid w, MonadWidget m) => MonadWidget (RWST r w s m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (RWST r w s m)) IO a -> RWST r w s m a Source #

(Monoid w, MonadWidget m) => MonadWidget (RWST r w s m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (RWST r w s m)) IO a -> RWST r w s m a Source #

MonadWidget m => MonadWidget (Pipe l i o u m) Source # 

Methods

liftWidgetT :: WidgetT (HandlerSite (Pipe l i o u m)) IO a -> Pipe l i o u m a Source #

getRouteToParent :: Monad m => HandlerT child (HandlerT parent m) (Route child -> Route parent) Source #

defaultLayoutSub :: Yesod parent => WidgetT child IO () -> HandlerT child (HandlerT parent IO) Html Source #

Approot

guessApproot :: Approot site Source #

Guess the approot based on request headers. For more information, see Network.Wai.Middleware.Approot

In the case of headers being unavailable, it falls back to ApprootRelative

Since 1.4.16

guessApprootOr :: Approot site -> Approot site Source #

Guess the approot based on request headers, with fall back to the specified AppRoot.

Since 1.4.16

getApprootText :: Approot site -> site -> Request -> Text Source #

Get the textual application root from an Approot value.

Since 1.4.17

Misc

yesodRender Source #

Arguments

:: Yesod y 
=> y 
-> ResolvedApproot 
-> Route y 
-> [(Text, Text)]

url query string

-> Text 

runFakeHandler :: (Yesod site, MonadIO m) => SessionMap -> (site -> Logger) -> site -> HandlerT site IO a -> m (Either ErrorResponse a) Source #

Deprecated: import runFakeHandler from Yesod.Core.Unsafe

LiteApp

newtype LiteApp Source #

Constructors

LiteApp 

Instances

Monoid LiteApp Source # 
ParseRoute LiteApp Source # 

Methods

parseRoute :: ([Text], [(Text, Text)]) -> Maybe (Route LiteApp) Source #

RenderRoute LiteApp Source # 

Associated Types

data Route LiteApp :: * Source #

Methods

renderRoute :: Route LiteApp -> ([Text], [(Text, Text)]) Source #

Yesod LiteApp Source # 

Methods

approot :: Approot LiteApp Source #

errorHandler :: ErrorResponse -> HandlerT LiteApp IO TypedContent Source #

defaultLayout :: WidgetT LiteApp IO () -> HandlerT LiteApp IO Html Source #

urlRenderOverride :: LiteApp -> Route LiteApp -> Maybe Builder Source #

urlParamRenderOverride :: LiteApp -> Route LiteApp -> [(Text, Text)] -> Maybe Builder Source #

isAuthorized :: Route LiteApp -> Bool -> HandlerT LiteApp IO AuthResult Source #

isWriteRequest :: Route LiteApp -> HandlerT LiteApp IO Bool Source #

authRoute :: LiteApp -> Maybe (Route LiteApp) Source #

cleanPath :: LiteApp -> [Text] -> Either [Text] [Text] Source #

joinPath :: LiteApp -> Text -> [Text] -> [(Text, Text)] -> Builder Source #

addStaticContent :: Text -> Text -> ByteString -> HandlerT LiteApp IO (Maybe (Either Text (Route LiteApp, [(Text, Text)]))) Source #

maximumContentLength :: LiteApp -> Maybe (Route LiteApp) -> Maybe Word64 Source #

makeLogger :: LiteApp -> IO Logger Source #

messageLoggerSource :: LiteApp -> Logger -> Loc -> LogSource -> LogLevel -> LogStr -> IO () Source #

jsLoader :: LiteApp -> ScriptLoadPosition LiteApp Source #

makeSessionBackend :: LiteApp -> IO (Maybe SessionBackend) Source #

fileUpload :: LiteApp -> RequestBodyLength -> FileUpload Source #

shouldLog :: LiteApp -> LogSource -> LogLevel -> Bool Source #

shouldLogIO :: LiteApp -> LogSource -> LogLevel -> IO Bool Source #

yesodMiddleware :: ToTypedContent res => HandlerT LiteApp IO res -> HandlerT LiteApp IO res Source #

yesodWithInternalState :: LiteApp -> Maybe (Route LiteApp) -> (InternalState -> IO a) -> IO a Source #

YesodDispatch LiteApp Source # 
Eq (Route LiteApp) Source # 
Ord (Route LiteApp) Source # 
Read (Route LiteApp) Source # 
Show (Route LiteApp) Source # 
data Route LiteApp Source # 

Low-level

yesodRunner :: (ToTypedContent res, Yesod site) => HandlerT site IO res -> YesodRunnerEnv site -> Maybe (Route site) -> Application Source #

Re-exports

formatW3 :: UTCTime -> Text Source #

Format a UTCTime in W3 format.

formatRFC1123 :: UTCTime -> Text Source #

Format as per RFC 1123.

formatRFC822 :: UTCTime -> Text Source #

Format as per RFC 822.

getCurrentMaxExpiresRFC1123 :: IO Text Source #

Get the time 365 days from now in RFC 1123 format. For use as an expiry date on a resource that never expires. See RFC 2616 section 14.21 for details.

class MonadTrans t where #

The class of monad transformers. Instances should satisfy the following laws, which state that lift is a monad transformation:

Instances

MonadTrans MaybeT 

Methods

lift :: Monad m => m a -> MaybeT m a #

MonadTrans CatchT 

Methods

lift :: Monad m => m a -> CatchT m a #

MonadTrans NoLoggingT 

Methods

lift :: Monad m => m a -> NoLoggingT m a #

MonadTrans LoggingT 

Methods

lift :: Monad m => m a -> LoggingT m a #

MonadTrans ListT 

Methods

lift :: Monad m => m a -> ListT m a #

MonadTrans ResourceT 

Methods

lift :: Monad m => m a -> ResourceT m a #

Monoid w => MonadTrans (WriterT w) 

Methods

lift :: Monad m => m a -> WriterT w m a #

Monoid w => MonadTrans (WriterT w) 

Methods

lift :: Monad m => m a -> WriterT w m a #

MonadTrans (StateT s) 

Methods

lift :: Monad m => m a -> StateT s m a #

MonadTrans (StateT s) 

Methods

lift :: Monad m => m a -> StateT s m a #

MonadTrans (ErrorT e) 

Methods

lift :: Monad m => m a -> ErrorT e m a #

MonadTrans (ExceptT e) 

Methods

lift :: Monad m => m a -> ExceptT e m a #

MonadTrans (IdentityT *) 

Methods

lift :: Monad m => m a -> IdentityT * m a #

MonadTrans (WidgetT site) # 

Methods

lift :: Monad m => m a -> WidgetT site m a #

MonadTrans (HandlerT site) # 

Methods

lift :: Monad m => m a -> HandlerT site m a #

MonadTrans (ReaderT * r) 

Methods

lift :: Monad m => m a -> ReaderT * r m a #

MonadTrans (ConduitM i o) 

Methods

lift :: Monad m => m a -> ConduitM i o m a #

MonadTrans (ContT * r) 

Methods

lift :: Monad m => m a -> ContT * r m a #

Monoid w => MonadTrans (RWST r w s) 

Methods

lift :: Monad m => m a -> RWST r w s m a #

Monoid w => MonadTrans (RWST r w s) 

Methods

lift :: Monad m => m a -> RWST r w s m a #

MonadTrans (Pipe l i o u) 

Methods

lift :: Monad m => m a -> Pipe l i o u m a #

class Monad m => MonadIO m where #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

Instances

MonadIO IO 

Methods

liftIO :: IO a -> IO a #

MonadIO m => MonadIO (MaybeT m) 

Methods

liftIO :: IO a -> MaybeT m a #

MonadIO m => MonadIO (CatchT m) 

Methods

liftIO :: IO a -> CatchT m a #

MonadIO m => MonadIO (NoLoggingT m) 

Methods

liftIO :: IO a -> NoLoggingT m a #

MonadIO m => MonadIO (LoggingT m) 

Methods

liftIO :: IO a -> LoggingT m a #

MonadIO m => MonadIO (ListT m) 

Methods

liftIO :: IO a -> ListT m a #

MonadIO m => MonadIO (ResourceT m) 

Methods

liftIO :: IO a -> ResourceT m a #

(Monoid w, MonadIO m) => MonadIO (WriterT w m) 

Methods

liftIO :: IO a -> WriterT w m a #

(Monoid w, MonadIO m) => MonadIO (WriterT w m) 

Methods

liftIO :: IO a -> WriterT w m a #

MonadIO m => MonadIO (StateT s m) 

Methods

liftIO :: IO a -> StateT s m a #

MonadIO m => MonadIO (StateT s m) 

Methods

liftIO :: IO a -> StateT s m a #

(Error e, MonadIO m) => MonadIO (ErrorT e m) 

Methods

liftIO :: IO a -> ErrorT e m a #

MonadIO m => MonadIO (ExceptT e m) 

Methods

liftIO :: IO a -> ExceptT e m a #

MonadIO m => MonadIO (IdentityT * m) 

Methods

liftIO :: IO a -> IdentityT * m a #

MonadIO m => MonadIO (WidgetT site m) # 

Methods

liftIO :: IO a -> WidgetT site m a #

MonadIO m => MonadIO (HandlerT site m) # 

Methods

liftIO :: IO a -> HandlerT site m a #

MonadIO m => MonadIO (ReaderT * r m) 

Methods

liftIO :: IO a -> ReaderT * r m a #

MonadIO m => MonadIO (ConduitM i o m) 

Methods

liftIO :: IO a -> ConduitM i o m a #

MonadIO m => MonadIO (ContT * r m) 

Methods

liftIO :: IO a -> ContT * r m a #

(Monoid w, MonadIO m) => MonadIO (RWST r w s m) 

Methods

liftIO :: IO a -> RWST r w s m a #

(Monoid w, MonadIO m) => MonadIO (RWST r w s m) 

Methods

liftIO :: IO a -> RWST r w s m a #

MonadIO m => MonadIO (Pipe l i o u m) 

Methods

liftIO :: IO a -> Pipe l i o u m a #

class (Applicative b, Applicative m, Monad b, Monad m) => MonadBase b m | m -> b where #

Instances

MonadBase [] [] 

Methods

liftBase :: [α] -> [α] #

MonadBase Maybe Maybe 

Methods

liftBase :: Maybe α -> Maybe α #

MonadBase IO IO 

Methods

liftBase :: IO α -> IO α #

MonadBase Identity Identity 

Methods

liftBase :: Identity α -> Identity α #

MonadBase STM STM 

Methods

liftBase :: STM α -> STM α #

MonadBase b m => MonadBase b (ResourceT m) 

Methods

liftBase :: b α -> ResourceT m α #

MonadBase b m => MonadBase b (NoLoggingT m) 

Methods

liftBase :: b α -> NoLoggingT m α #

MonadBase b m => MonadBase b (LoggingT m) 

Methods

liftBase :: b α -> LoggingT m α #

MonadBase b m => MonadBase b (MaybeT m) 

Methods

liftBase :: b α -> MaybeT m α #

MonadBase b m => MonadBase b (ListT m) 

Methods

liftBase :: b α -> ListT m α #

(Monoid w, MonadBase b m) => MonadBase b (WriterT w m) 

Methods

liftBase :: b α -> WriterT w m α #

(Monoid w, MonadBase b m) => MonadBase b (WriterT w m) 

Methods

liftBase :: b α -> WriterT w m α #

MonadBase b m => MonadBase b (StateT s m) 

Methods

liftBase :: b α -> StateT s m α #

MonadBase b m => MonadBase b (StateT s m) 

Methods

liftBase :: b α -> StateT s m α #

MonadBase b m => MonadBase b (IdentityT * m) 

Methods

liftBase :: b α -> IdentityT * m α #

MonadBase b m => MonadBase b (ExceptT e m) 

Methods

liftBase :: b α -> ExceptT e m α #

(Error e, MonadBase b m) => MonadBase b (ErrorT e m) 

Methods

liftBase :: b α -> ErrorT e m α #

MonadBase b m => MonadBase b (HandlerT site m) # 

Methods

liftBase :: b α -> HandlerT site m α #

MonadBase b m => MonadBase b (WidgetT site m) # 

Methods

liftBase :: b α -> WidgetT site m α #

MonadBase base m => MonadBase base (ConduitM i o m) 

Methods

liftBase :: base α -> ConduitM i o m α #

MonadBase b m => MonadBase b (ReaderT * r m) 

Methods

liftBase :: b α -> ReaderT * r m α #

MonadBase b m => MonadBase b (ContT * r m) 

Methods

liftBase :: b α -> ContT * r m α #

(Monoid w, MonadBase b m) => MonadBase b (RWST r w s m) 

Methods

liftBase :: b α -> RWST r w s m α #

(Monoid w, MonadBase b m) => MonadBase b (RWST r w s m) 

Methods

liftBase :: b α -> RWST r w s m α #

MonadBase base m => MonadBase base (Pipe l i o u m) 

Methods

liftBase :: base α -> Pipe l i o u m α #

MonadBase ((->) r) ((->) r) 

Methods

liftBase :: (r -> α) -> r -> α #

MonadBase (Either e) (Either e) 

Methods

liftBase :: Either e α -> Either e α #

MonadBase (ST s) (ST s) 

Methods

liftBase :: ST s α -> ST s α #

MonadBase (ST s) (ST s) 

Methods

liftBase :: ST s α -> ST s α #

class MonadBase b m => MonadBaseControl b m | m -> b #

Minimal complete definition

liftBaseWith, restoreM

Instances

MonadBaseControl [] [] 

Associated Types

type StM ([] :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase [] [] -> [a]) -> [a] #

restoreM :: StM [] a -> [a] #

MonadBaseControl Maybe Maybe 

Associated Types

type StM (Maybe :: * -> *) a :: * #

MonadBaseControl IO IO 

Associated Types

type StM (IO :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase IO IO -> IO a) -> IO a #

restoreM :: StM IO a -> IO a #

MonadBaseControl Identity Identity 

Associated Types

type StM (Identity :: * -> *) a :: * #

MonadBaseControl STM STM 

Associated Types

type StM (STM :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase STM STM -> STM a) -> STM a #

restoreM :: StM STM a -> STM a #

MonadBaseControl b m => MonadBaseControl b (ResourceT m) 

Associated Types

type StM (ResourceT m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (ResourceT m) b -> b a) -> ResourceT m a #

restoreM :: StM (ResourceT m) a -> ResourceT m a #

MonadBaseControl b m => MonadBaseControl b (MaybeT m) 

Associated Types

type StM (MaybeT m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (MaybeT m) b -> b a) -> MaybeT m a #

restoreM :: StM (MaybeT m) a -> MaybeT m a #

MonadBaseControl b m => MonadBaseControl b (ListT m) 

Associated Types

type StM (ListT m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (ListT m) b -> b a) -> ListT m a #

restoreM :: StM (ListT m) a -> ListT m a #

MonadBaseControl b m => MonadBaseControl b (NoLoggingT m) 

Associated Types

type StM (NoLoggingT m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (NoLoggingT m) b -> b a) -> NoLoggingT m a #

restoreM :: StM (NoLoggingT m) a -> NoLoggingT m a #

MonadBaseControl b m => MonadBaseControl b (LoggingT m) 

Associated Types

type StM (LoggingT m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (LoggingT m) b -> b a) -> LoggingT m a #

restoreM :: StM (LoggingT m) a -> LoggingT m a #

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (WriterT w m) 

Associated Types

type StM (WriterT w m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (WriterT w m) b -> b a) -> WriterT w m a #

restoreM :: StM (WriterT w m) a -> WriterT w m a #

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (WriterT w m) 

Associated Types

type StM (WriterT w m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (WriterT w m) b -> b a) -> WriterT w m a #

restoreM :: StM (WriterT w m) a -> WriterT w m a #

MonadBaseControl b m => MonadBaseControl b (StateT s m) 

Associated Types

type StM (StateT s m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (StateT s m) b -> b a) -> StateT s m a #

restoreM :: StM (StateT s m) a -> StateT s m a #

MonadBaseControl b m => MonadBaseControl b (StateT s m) 

Associated Types

type StM (StateT s m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (StateT s m) b -> b a) -> StateT s m a #

restoreM :: StM (StateT s m) a -> StateT s m a #

MonadBaseControl b m => MonadBaseControl b (IdentityT * m) 

Associated Types

type StM (IdentityT * m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (IdentityT * m) b -> b a) -> IdentityT * m a #

restoreM :: StM (IdentityT * m) a -> IdentityT * m a #

MonadBaseControl b m => MonadBaseControl b (ExceptT e m) 

Associated Types

type StM (ExceptT e m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (ExceptT e m) b -> b a) -> ExceptT e m a #

restoreM :: StM (ExceptT e m) a -> ExceptT e m a #

(Error e, MonadBaseControl b m) => MonadBaseControl b (ErrorT e m) 

Associated Types

type StM (ErrorT e m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (ErrorT e m) b -> b a) -> ErrorT e m a #

restoreM :: StM (ErrorT e m) a -> ErrorT e m a #

MonadBaseControl b m => MonadBaseControl b (HandlerT site m) #

Note: although we provide a MonadBaseControl instance, lifted-base's fork function is incompatible with the underlying ResourceT system. Instead, if you must fork a separate thread, you should use resourceForkIO.

Using fork usually leads to an exception that says "Control.Monad.Trans.Resource.register': The mutable state is being accessed after cleanup. Please contact the maintainers."

Associated Types

type StM (HandlerT site m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (HandlerT site m) b -> b a) -> HandlerT site m a #

restoreM :: StM (HandlerT site m) a -> HandlerT site m a #

MonadBaseControl b m => MonadBaseControl b (WidgetT site m) # 

Associated Types

type StM (WidgetT site m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (WidgetT site m) b -> b a) -> WidgetT site m a #

restoreM :: StM (WidgetT site m) a -> WidgetT site m a #

MonadBaseControl b m => MonadBaseControl b (ReaderT * r m) 

Associated Types

type StM (ReaderT * r m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (ReaderT * r m) b -> b a) -> ReaderT * r m a #

restoreM :: StM (ReaderT * r m) a -> ReaderT * r m a #

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (RWST r w s m) 

Associated Types

type StM (RWST r w s m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (RWST r w s m) b -> b a) -> RWST r w s m a #

restoreM :: StM (RWST r w s m) a -> RWST r w s m a #

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (RWST r w s m) 

Associated Types

type StM (RWST r w s m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (RWST r w s m) b -> b a) -> RWST r w s m a #

restoreM :: StM (RWST r w s m) a -> RWST r w s m a #

MonadBaseControl ((->) r) ((->) r) 

Associated Types

type StM ((->) r :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase ((->) r) ((->) r) -> r -> a) -> r -> a #

restoreM :: StM ((->) r) a -> r -> a #

MonadBaseControl (Either e) (Either e) 

Associated Types

type StM (Either e :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (Either e) (Either e) -> Either e a) -> Either e a #

restoreM :: StM (Either e) a -> Either e a #

MonadBaseControl (ST s) (ST s) 

Associated Types

type StM (ST s :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (ST s) (ST s) -> ST s a) -> ST s a #

restoreM :: StM (ST s) a -> ST s a #

MonadBaseControl (ST s) (ST s) 

Associated Types

type StM (ST s :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (ST s) (ST s) -> ST s a) -> ST s a #

restoreM :: StM (ST s) a -> ST s a #

class (MonadThrow m, MonadIO m, Applicative m, MonadBase IO m) => MonadResource m where #

A Monad which allows for safe resource allocation. In theory, any monad transformer stack which includes a ResourceT can be an instance of MonadResource.

Note: runResourceT has a requirement for a MonadBaseControl IO m monad, which allows control operations to be lifted. A MonadResource does not have this requirement. This means that transformers such as ContT can be an instance of MonadResource. However, the ContT wrapper will need to be unwrapped before calling runResourceT.

Since 0.3.0

Instances

MonadResource m => MonadResource (MaybeT m) 

Methods

liftResourceT :: ResourceT IO a -> MaybeT m a #

MonadResource m => MonadResource (NoLoggingT m) 
MonadResource m => MonadResource (LoggingT m) 

Methods

liftResourceT :: ResourceT IO a -> LoggingT m a #

MonadResource m => MonadResource (ListT m) 

Methods

liftResourceT :: ResourceT IO a -> ListT m a #

(MonadThrow m, MonadBase IO m, MonadIO m, Applicative m) => MonadResource (ResourceT m) 

Methods

liftResourceT :: ResourceT IO a -> ResourceT m a #

(Monoid w, MonadResource m) => MonadResource (WriterT w m) 

Methods

liftResourceT :: ResourceT IO a -> WriterT w m a #

(Monoid w, MonadResource m) => MonadResource (WriterT w m) 

Methods

liftResourceT :: ResourceT IO a -> WriterT w m a #

MonadResource m => MonadResource (StateT s m) 

Methods

liftResourceT :: ResourceT IO a -> StateT s m a #

MonadResource m => MonadResource (StateT s m) 

Methods

liftResourceT :: ResourceT IO a -> StateT s m a #

(Error e, MonadResource m) => MonadResource (ErrorT e m) 

Methods

liftResourceT :: ResourceT IO a -> ErrorT e m a #

MonadResource m => MonadResource (ExceptT e m) 

Methods

liftResourceT :: ResourceT IO a -> ExceptT e m a #

MonadResource m => MonadResource (IdentityT * m) 

Methods

liftResourceT :: ResourceT IO a -> IdentityT * m a #

(Applicative m, MonadIO m, MonadBase IO m, MonadThrow m) => MonadResource (WidgetT site m) # 

Methods

liftResourceT :: ResourceT IO a -> WidgetT site m a #

(MonadIO m, MonadBase IO m, MonadThrow m) => MonadResource (HandlerT site m) # 

Methods

liftResourceT :: ResourceT IO a -> HandlerT site m a #

MonadResource m => MonadResource (ReaderT * r m) 

Methods

liftResourceT :: ResourceT IO a -> ReaderT * r m a #

MonadResource m => MonadResource (ConduitM i o m) 

Methods

liftResourceT :: ResourceT IO a -> ConduitM i o m a #

MonadResource m => MonadResource (ContT * r m) 

Methods

liftResourceT :: ResourceT IO a -> ContT * r m a #

(Monoid w, MonadResource m) => MonadResource (RWST r w s m) 

Methods

liftResourceT :: ResourceT IO a -> RWST r w s m a #

(Monoid w, MonadResource m) => MonadResource (RWST r w s m) 

Methods

liftResourceT :: ResourceT IO a -> RWST r w s m a #

MonadResource m => MonadResource (Pipe l i o u m) 

Methods

liftResourceT :: ResourceT IO a -> Pipe l i o u m a #

class Monad m => MonadLogger m #

A Monad which has the ability to log messages in some manner.

Instances

MonadLogger m => MonadLogger (MaybeT m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> MaybeT m () #

Monad m => MonadLogger (NoLoggingT m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> NoLoggingT m () #

MonadIO m => MonadLogger (LoggingT m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> LoggingT m () #

MonadLogger m => MonadLogger (ListT m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ListT m () #

MonadLogger m => MonadLogger (ResourceT m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ResourceT m () #

(MonadLogger m, Monoid w) => MonadLogger (WriterT w m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> WriterT w m () #

(MonadLogger m, Monoid w) => MonadLogger (WriterT w m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> WriterT w m () #

MonadLogger m => MonadLogger (StateT s m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> StateT s m () #

MonadLogger m => MonadLogger (StateT s m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> StateT s m () #

(MonadLogger m, Error e) => MonadLogger (ErrorT e m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ErrorT e m () #

MonadLogger m => MonadLogger (ExceptT e m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ExceptT e m () #

MonadLogger m => MonadLogger (IdentityT * m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> IdentityT * m () #

MonadIO m => MonadLogger (WidgetT site m) # 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> WidgetT site m () #

MonadIO m => MonadLogger (HandlerT site m) # 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> HandlerT site m () #

MonadLogger m => MonadLogger (ReaderT * r m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ReaderT * r m () #

MonadLogger m => MonadLogger (ConduitM i o m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ConduitM i o m () #

MonadLogger m => MonadLogger (ContT * r m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> ContT * r m () #

(MonadLogger m, Monoid w) => MonadLogger (RWST r w s m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> RWST r w s m () #

(MonadLogger m, Monoid w) => MonadLogger (RWST r w s m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> RWST r w s m () #

MonadLogger m => MonadLogger (Pipe l i o u m) 

Methods

monadLoggerLog :: ToLogStr msg => Loc -> LogSource -> LogLevel -> msg -> Pipe l i o u m () #

Commonly referenced functions/datatypes

type Application = Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived #

The WAI application.

Note that, since WAI 3.0, this type is structured in continuation passing style to allow for proper safe resource handling. This was handled in the past via other means (e.g., ResourceT). As a demonstration:

app :: Application
app req respond = bracket_
    (putStrLn "Allocating scarce resource")
    (putStrLn "Cleaning up")
    (respond $ responseLBS status200 [] "Hello World")

Utilities

Shakespeare

Hamlet

hamlet :: QuasiQuoter #

Hamlet quasi-quoter. May only be used to generate expressions.

Generated expression have type HtmlUrl url, for some url.

data MyRoute = Home

render :: Render MyRoute
render Home _ = "/home"

>>> putStrLn (renderHtml ([hamlet|<a href=@{Home}>Home|] render))
<a href="/home">Home</a>

shamlet :: QuasiQuoter #

"Simple Hamlet" quasi-quoter. May only be used to generate expressions.

Generated expressions have type Html.

>>> putStrLn (renderHtml [shamlet|<div>Hello, world!|])
<div>Hello, world!</div>

xhamlet :: QuasiQuoter #

Like hamlet, but produces XHTML.

type HtmlUrl url = Render url -> Html #

A function generating an Html given a URL-rendering function.

Julius

type JavascriptUrl url = (url -> [(Text, Text)] -> Text) -> Javascript #

Return type of template-reading functions.

renderJavascriptUrl :: (url -> [(Text, Text)] -> Text) -> JavascriptUrl url -> Text #

render with route interpolation. If using this module standalone, apart from type-safe routes, a dummy renderer can be used:

renderJavascriptUrl (\_ _ -> undefined) javascriptUrl

When using Yesod, a renderer is generated for you, which can be accessed within the GHandler monad: getUrlRenderParams.

Cassius/Lucius

lucius :: QuasiQuoter #

>>> renderCss ([lucius|foo{bar:baz}|] undefined)
"foo{bar:baz}"

type CssUrl url = (url -> [(Text, Text)] -> Text) -> Css #

renderCssUrl :: (url -> [(Text, Text)] -> Text) -> CssUrl url -> Text #