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

Safe HaskellNone
LanguageHaskell98

Yesod.Core.Types

Synopsis

Documentation

type SaveSession Source

Arguments

 = SessionMap

The session contents after running the handler

-> IO [Header] 

newtype SessionBackend Source

Constructors

SessionBackend 

Fields

sbLoadSession :: Request -> IO (SessionMap, SaveSession)

Return the session data and a function to save the session

data YesodRequest Source

The parsed request information. This type augments the standard WAI Request with additional information.

Constructors

YesodRequest 

Fields

reqGetParams :: ![(Text, Text)]

Same as queryString, but decoded to Text.

reqCookies :: ![(Text, Text)]
 
reqWaiRequest :: !Request
 
reqLangs :: ![Text]

Languages which the client supports. This is an ordered list by preference.

reqToken :: !(Maybe Text)

A random, session-specific token used to prevent CSRF attacks.

reqSession :: !SessionMap

Initial session sent from the client.

Since 1.2.0

reqAccept :: ![ContentType]

An ordered list of the accepted content types.

Since 1.2.0

data YesodResponse Source

An augmented WAI Response. This can either be a standard Response, or a higher-level data structure which Yesod will turn into a Response.

type RequestBodyContents = ([(Text, Text)], [(Text, FileInfo)]) Source

A tuple containing both the POST parameters and submitted files.

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) 

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

type Texts = [Text] Source

data RunHandlerEnv site Source

Constructors

RunHandlerEnv 

Fields

rheRender :: !(Route site -> [(Text, Text)] -> Text)
 
rheRoute :: !(Maybe (Route site))
 
rheSite :: !site
 
rheUpload :: !(RequestBodyLength -> FileUpload)
 
rheLog :: !(Loc -> LogSource -> LogLevel -> LogStr -> IO ())
 
rheOnError :: !(ErrorResponse -> YesodApp)

How to respond when an error is thrown internally.

Since 1.2.0

rheMaxExpires :: !Text
 

data HandlerData site parentRoute Source

data YesodSubRunnerEnv sub parent parentMonad Source

Constructors

YesodSubRunnerEnv 

Fields

ysreParentRunner :: !(ParentRunner parent parentMonad)
 
ysreGetSub :: !(parent -> sub)
 
ysreToParentRoute :: !(Route sub -> Route parent)
 
ysreParentEnv :: !(YesodRunnerEnv parent)
 

type ParentRunner parent m = m TypedContent -> YesodRunnerEnv parent -> Maybe (Route parent) -> Application Source

newtype HandlerT site m a Source

A generic handler monad, which can have a different subsite and master site. We define a newtype for better error message.

Constructors

HandlerT 

Fields

unHandlerT :: HandlerData site (MonadRoute m) -> m a
 

Instances

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

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."

MonadBase b m => MonadBase b (HandlerT site m) Source 
Monad m => MonadReader site (HandlerT site m) Source 
MonadTrans (HandlerT site) Source 
Monad m => Monad (HandlerT site m) Source 
Monad m => Functor (HandlerT site m) Source 
Monad m => Applicative (HandlerT site m) Source 
MonadActive m => MonadActive (HandlerT site m) Source 
MonadThrow m => MonadThrow (HandlerT site m) Source 
MonadCatch m => MonadCatch (HandlerT site m) Source 
MonadMask m => MonadMask (HandlerT site m) Source 
MonadIO m => MonadLogger (HandlerT site m) Source 
MonadIO m => MonadLoggerIO (HandlerT site m) Source 
MonadIO m => MonadIO (HandlerT site m) Source 
(MonadIO m, MonadBase IO m, MonadThrow m) => MonadResource (HandlerT site m) Source 
MonadResourceBase m => MonadHandler (HandlerT site m) Source 
type MonadRoute (HandlerT site m) = Route site Source 
type HandlerSite (HandlerT site m) = site Source 
type StM (HandlerT site m) a = StM m a Source 

type family MonadRoute m Source

Instances

type MonadRoute IO = () Source 
type MonadRoute (HandlerT site m) = Route site Source 

data GHState Source

Constructors

GHState 

type YesodApp = YesodRequest -> ResourceT IO YesodResponse Source

An extension of the basic WAI Application datatype to provide extra features needed by Yesod. Users should never need to use this directly, as the HandlerT monad and template haskell code should hide it away.

newtype WidgetT site m a Source

A generic widget, allowing specification of both the subsite and master site datatypes. While this is simply a WriterT, we define a newtype for better error messages.

Constructors

WidgetT 

Fields

unWidgetT :: HandlerData site (MonadRoute m) -> m (a, GWData (Route site))
 

Instances

MonadBaseControl b m => MonadBaseControl b (WidgetT site m) Source 
MonadBase b m => MonadBase b (WidgetT site m) Source 
Monad m => MonadReader site (WidgetT site m) Source 
((~) * site' site, (~) (* -> *) IO m, (~) * a ()) => ToWidget site' (WidgetT site m a) Source 
MonadTrans (WidgetT site) Source 
Monad m => Monad (WidgetT site m) Source 
Monad m => Functor (WidgetT site m) Source 
Monad m => Applicative (WidgetT site m) Source 
MonadActive m => MonadActive (WidgetT site m) Source 
MonadThrow m => MonadThrow (WidgetT site m) Source 
MonadCatch m => MonadCatch (WidgetT site m) Source 
MonadMask m => MonadMask (WidgetT site m) Source 
MonadIO m => MonadLogger (WidgetT site m) Source 
MonadIO m => MonadLoggerIO (WidgetT site m) Source 
MonadIO m => MonadIO (WidgetT site m) Source 
(Applicative m, MonadIO m, MonadBase IO m, MonadThrow m) => MonadResource (WidgetT site m) Source 
MonadResourceBase m => MonadWidget (WidgetT site m) Source 
MonadResourceBase m => MonadHandler (WidgetT site m) Source 
(Monad m, (~) * a ()) => IsString (WidgetT site m a) Source

A String can be trivially promoted to a widget.

For example, in a yesod-scaffold site you could use:

getHomeR = do defaultLayout "Widget text"
((~) * a (), Monad m) => Monoid (WidgetT site m a) Source 
((~) * a (), Monad m) => Semigroup (WidgetT site m a) Source 
type HandlerSite (WidgetT site m) = site Source 
type StM (WidgetT site m) a = StM m (a, GWData (Route site)) Source 

type RY master = Route master -> [(Text, Text)] -> Text Source

newtype CssBuilder Source

Newtype wrapper allowing injection of arbitrary content into CSS.

Usage:

toWidget $ CssBuilder "p { color: red }"

Since: 1.1.3

Constructors

CssBuilder 

Instances

ToWidgetHead site CssBuilder Source 
ToWidgetMedia site CssBuilder Source 
ToWidget site CssBuilder Source 
(~) * render (RY site) => ToWidgetHead site (render -> CssBuilder) Source 
(~) * render (RY site) => ToWidgetMedia site (render -> CssBuilder) Source 
(~) * render (RY site) => ToWidget site (render -> CssBuilder) Source 

data PageContent url Source

Content for a web page. By providing this datatype, we can easily create generic site templates, which would have the type signature:

PageContent url -> HtmlUrl url

Constructors

PageContent 

Fields

pageTitle :: Html
 
pageHead :: HtmlUrl url
 
pageBody :: HtmlUrl url
 

type RepHtml = Html Source

Deprecated: Please use Html instead

newtype DontFullyEvaluate a Source

Prevents a response body from being fully evaluated before sending the request.

Since 1.1.0

Constructors

DontFullyEvaluate 

Fields

unDontFullyEvaluate :: a
 

data ErrorResponse Source

Responses to indicate some form of an error occurred.

data Location url Source

Constructors

Local url 
Remote Text 

Instances

Eq url => Eq (Location url) Source 
Show url => Show (Location url) Source 

newtype UniqueList x Source

A diff list that does not directly enforce uniqueness. When creating a widget Yesod will use nub to make it unique.

Constructors

UniqueList ([x] -> [x]) 

data Script url Source

Constructors

Script 

Instances

Eq url => Eq (Script url) Source 
Show url => Show (Script url) Source 

data Stylesheet url Source

Constructors

Stylesheet 

Instances

Eq url => Eq (Stylesheet url) Source 
Show url => Show (Stylesheet url) Source 

newtype Title Source

Constructors

Title 

Fields

unTitle :: Html
 

newtype Head url Source

Constructors

Head (HtmlUrl url) 

Instances

newtype Body url Source

Constructors

Body (HtmlUrl url) 

Instances

type CssBuilderUrl a = (a -> [(Text, Text)] -> Text) -> Builder Source