| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Yesod.Core.Dispatch
Synopsis
- parseRoutes :: QuasiQuoter
- parseRoutesNoCheck :: QuasiQuoter
- parseRoutesFile :: FilePath -> Q Exp
- parseRoutesFileNoCheck :: FilePath -> Q Exp
- mkYesod :: String -> [ResourceTree String] -> Q [Dec]
- mkYesodOpts :: RouteOpts -> String -> [ResourceTree String] -> Q [Dec]
- mkYesodWith :: [[String]] -> String -> [String] -> [ResourceTree String] -> Q [Dec]
- mkYesodData :: String -> [ResourceTree String] -> Q [Dec]
- mkYesodDataOpts :: RouteOpts -> String -> [ResourceTree String] -> Q [Dec]
- mkYesodSubData :: String -> [ResourceTree String] -> Q [Dec]
- mkYesodSubDataOpts :: RouteOpts -> String -> [ResourceTree String] -> Q [Dec]
- mkYesodDispatch :: String -> [ResourceTree String] -> Q [Dec]
- mkYesodDispatchOpts :: RouteOpts -> String -> [ResourceTree String] -> Q [Dec]
- mkYesodSubDispatch :: [ResourceTree a] -> Q Exp
- mkYesodSubDispatchInstance :: String -> [ResourceTree String] -> Q [Dec]
- mkYesodSubDispatchInstanceOpts :: RouteOpts -> String -> [ResourceTree String] -> Q [Dec]
- mkNestedSubDispatchInstance :: RouteOpts -> String -> Cxt -> TyArgs -> (Exp -> Q Exp) -> [ResourceTree String] -> Q [Dec]
- data TyArgs
- = NoTyArgs
- | SomeTyArgs (NonEmpty (Type, Name))
- data RouteOpts
- defaultOpts :: RouteOpts
- setEqDerived :: Bool -> RouteOpts -> RouteOpts
- setShowDerived :: Bool -> RouteOpts -> RouteOpts
- setReadDerived :: Bool -> RouteOpts -> RouteOpts
- setCreateResources :: Bool -> RouteOpts -> RouteOpts
- setFocusOnNestedRoute :: String -> RouteOpts -> RouteOpts
- unsetFocusOnNestedRoute :: RouteOpts -> RouteOpts
- setParameterizedSubroute :: Bool -> RouteOpts -> RouteOpts
- setNestedRouteFallthrough :: Bool -> RouteOpts -> RouteOpts
- defaultGen :: IO Int
- getGetMaxExpires :: IO (IO Text)
- class PathPiece s where
- fromPathPiece :: Text -> Maybe s
- toPathPiece :: s -> Text
- class PathMultiPiece s where
- fromPathMultiPiece :: [Text] -> Maybe s
- toPathMultiPiece :: s -> [Text]
- type Texts = [Text]
- toWaiApp :: YesodDispatch site => site -> IO Application
- toWaiAppPlain :: YesodDispatch site => site -> IO Application
- class RedirectUrl site url => UrlToDispatch url site where
- urlToDispatch :: url -> YesodRunnerEnv site -> Application
- mkYesodRunnerEnv :: Yesod site => site -> IO (YesodRunnerEnv site)
- toWaiAppPlainNested :: (site ~ ParentSite route, Yesod site, YesodDispatchNested route, ToParentRoute route) => Proxy route -> ParentArgs route -> site -> IO Application
- toWaiAppYre :: YesodDispatch site => YesodRunnerEnv site -> Application
- toWaiAppYreNested :: (Yesod (ParentSite a), YesodDispatchNested a, ToParentRoute a) => Proxy a -> ParentArgs a -> YesodRunnerEnv (ParentSite a) -> Application
- warp :: YesodDispatch site => Int -> site -> IO ()
- warpDebug :: YesodDispatch site => Int -> site -> IO ()
- warpEnv :: YesodDispatch site => site -> IO ()
- mkDefaultMiddlewares :: Logger -> IO Middleware
- defaultMiddlewaresNoLogging :: Middleware
- class RenderRouteNested a => YesodSubDispatchNested a where
- yesodSubDispatchNested :: Proxy a -> ParentArgs a -> (a -> Route (ParentSite a)) -> YesodSubRunnerEnv (ParentSite a) master -> Request -> Maybe ((Response -> IO ResponseReceived) -> IO ResponseReceived)
- newtype WaiSubsite = WaiSubsite {}
- newtype WaiSubsiteWithAuth = WaiSubsiteWithAuth {}
Quasi-quoted routing
parseRoutes :: QuasiQuoter Source #
A quasi-quoter to parse a string into a list of Resources. Checks for
overlapping routes, failing if present; use parseRoutesNoCheck to skip the
checking. See documentation site for details on syntax.
parseRoutesNoCheck :: QuasiQuoter Source #
Same as parseRoutes, but performs no overlap checking.
parseRoutesFile :: FilePath -> Q Exp Source #
Same as parseRoutes, but uses an external file instead of quasiquotation.
The recommended file extension is .yesodroutes.
parseRoutesFileNoCheck :: FilePath -> Q Exp Source #
Same as parseRoutesNoCheck, but uses an external file instead of quasiquotation.
The recommended file extension is .yesodroutes.
Arguments
| :: String | name of the argument datatype |
| -> [ResourceTree String] | |
| -> Q [Dec] |
Generates URL datatype and site function for the given Resources. This
is used for creating sites, not subsites. See mkYesodSubData and mkYesodSubDispatch for the latter.
Use parseRoutes to create the Resources.
Contexts and type variables in the name of the datatype are parsed.
For example, a datatype App a with typeclass constraint MyClass a can be written as "(MyClass a) => App a".
mkYesodOpts :: RouteOpts -> String -> [ResourceTree String] -> Q [Dec] Source #
mkYesod but with custom options.
Since: 1.6.25.0
Arguments
| :: [[String]] | list of contexts |
| -> String | name of the argument datatype |
| -> [String] | list of type variables |
| -> [ResourceTree String] | |
| -> Q [Dec] |
Deprecated: Contexts and type variables are now parsed from the name in mkYesod. https://github.com/yesodweb/yesod/pull/1366
Similar to mkYesod, except contexts and type variables are not parsed.
Instead, they are explicitly provided.
You can write (MyClass a) => App a with mkYesodWith [["MyClass","a"]] "App" ["a"] ....
More fine-grained
mkYesodData :: String -> [ResourceTree String] -> Q [Dec] Source #
Sometimes, you will want to declare your routes in one file and define
your handlers elsewhere. For example, this is the only way to break up a
monolithic file into smaller parts. Use this function, paired with
mkYesodDispatch, to do just that.
mkYesodDataOpts :: RouteOpts -> String -> [ResourceTree String] -> Q [Dec] Source #
mkYesodData but with custom options.
Since: 1.6.25.0
mkYesodSubData :: String -> [ResourceTree String] -> Q [Dec] Source #
mkYesodSubDataOpts :: RouteOpts -> String -> [ResourceTree String] -> Q [Dec] Source #
Since: 1.6.25.0
mkYesodDispatch :: String -> [ResourceTree String] -> Q [Dec] Source #
See mkYesodData.
mkYesodDispatchOpts :: RouteOpts -> String -> [ResourceTree String] -> Q [Dec] Source #
See mkYesodDataOpts
Since: 1.6.25.0
mkYesodSubDispatch :: [ResourceTree a] -> Q Exp Source #
mkYesodSubDispatchInstance Source #
Arguments
| :: String | Foundation type with optional context, e.g. |
| -> [ResourceTree String] | Resources (e.g. |
| -> Q [Dec] |
Generate both YesodSubDispatch and YesodSubDispatchNested instances
for a parameterized subsite. This is the subsite equivalent of using
mkYesod for top-level sites.
Usage:
mkYesodSubDispatchInstance "(MyClass a) => MySub a" resourcesMySub
This generates:
- A
YesodSubDispatchinstance usingmkYesodSubDispatch YesodSubDispatchNestedinstances for any nested route fragments
The generated instances quantify over the master site and constrain it
only through the subsite's own class. For a parameterized subsite this
normally means the subsite's class carries a subsite -> master functional
dependency (so master is determined) and the using module enables
UndecidableInstances (the instance contexts mention type-family
applications and non-variable arguments), along with FlexibleContexts,
FlexibleInstances, MultiParamTypeClasses and TypeFamilies. The nested
route datatype must also declare exactly as many type parameters as the
subsite has type arguments (see the arity note below).
Since: 1.7.0.0
mkYesodSubDispatchInstanceOpts Source #
Arguments
| :: RouteOpts | |
| -> String | Foundation type with optional context, e.g. |
| -> [ResourceTree String] | Resources (e.g. |
| -> Q [Dec] |
Like mkYesodSubDispatchInstance, but takes a RouteOpts so a subsite can
control nested-route generation — most usefully setNestedRouteFallthrough
(which mkYesodSubDispatchInstance leaves at its default of False). The
flag is threaded into both the yesodSubDispatch body (so the subsite's own
top-level parent clauses fall through to later siblings on an inner miss) and
the generated YesodSubDispatchNested fragment instances.
Since: 1.7.0.0
Splitting a subsite's nested routes across modules
These re-exports let a separately-compiled module generate a
subsite's YesodSubDispatchNested instance by hand (see the
subsite-route-splitting recipe in docs/split-route-compilation.md).
mkNestedSubDispatchInstance takes the resources as
[ (the ResourceTree String]parseRoutes quasi-quoter's output)
and parses them internally, so no manual type-parsing is needed.
Since: 1.7.0.0
mkNestedSubDispatchInstance Source #
Arguments
| :: RouteOpts | |
| -> String | target nested route name |
| -> Cxt | instance context |
| -> TyArgs | type arguments |
| -> (Exp -> Q Exp) | unwrapper |
| -> [ResourceTree String] | all resources (as parsed from source) |
| -> Q [Dec] |
Generate a YesodSubDispatchNested instance for a nested route within a
subsite, for hand-written split-route modules (see the subsite-splitting
recipe in docs/split-route-compilation.md).
Takes the resources as [ — exactly the form the
ResourceTree String]parseRoutes quasi-quoter produces — and parses them to Type internally
via parseResourceTypes, so the caller never touches the partial
parseType/dropBracket. A malformed type fails the splice with an
attributed error instead.
Since: 1.7.0.0
Since: 1.7.0.0
The type arguments of a route datatype, paired with the source Name each
was derived from. A monomorphic site like App has NoTyArgs; a
parameterized one like MySub subsite has SomeTyArgs.
Carrying the (non-)emptiness in the type — rather than as a bare list with a
separate null check — keeps "are there type args?" and "what are they?"
a single fact, so the populated branch hands you the NonEmpty directly.
Since: 1.7.0.0
Constructors
| NoTyArgs | |
| SomeTyArgs (NonEmpty (Type, Name)) |
Route generation options
General opts data type for generating yesod.
Contains options for customizing code generation for the router in
mkYesodData, including what type class instances will be derived for
the route datatype, whether to parameterize subroutes,
and whether or not to create the resources :: [ResourceTree String] value.
Use the setting functions on defaultOpts to set specific fields.
Since: 1.6.25.0
defaultOpts :: RouteOpts Source #
Default options for generating routes.
The defaults are:
setEqDerived,setShowDerived,setReadDerived:True— deriveEq,ShowandReadfor the route datatype.setCreateResources:True— emit theresourcesSite :: [ResourceTree String]term.setParameterizedSubroute:False— subroutes are unparameterized.setFocusOnNestedRoute: unset — generate the whole route tree rather than focusing on a single nested route.setNestedRouteFallthrough:False— a nested route that fails to match throwsnotFoundinstead of falling through.
Use the set* functions to override individual fields.
Since: 1.6.25.0
setEqDerived :: Bool -> RouteOpts -> RouteOpts Source #
When True, derive an Eq instance for the route datatype.
Default: True.
Since: 1.6.25.0
setShowDerived :: Bool -> RouteOpts -> RouteOpts Source #
When True, derive a Show instance for the route datatype.
Default: True.
Since: 1.6.25.0
setReadDerived :: Bool -> RouteOpts -> RouteOpts Source #
When True, derive a Read instance for the route datatype.
Default: True.
Since: 1.6.25.0
setCreateResources :: Bool -> RouteOpts -> RouteOpts Source #
Determine whether or not to generate the resourcesApp value.
Disabling this can be useful if you are creating the routes ::
[ResourceTree String] elsewhere in your module, and referring to it
here. The resourcesApp can become very large in large applications,
and duplicating it can result in signifiacntly higher compile times.
Default: True.
Since: 1.6.28.0
setFocusOnNestedRoute :: String -> RouteOpts -> RouteOpts Source #
If you set this with routeName, then the code generation will
generate code for the routeName to be imported in the main dispatch
class. This allows you to generate code in separate modules.
Example:
First, you would put your route definitions into their own file.
module App.Routes.Resources where
import Yesod.Core
appResources :: [ResourceTree String]
appResources = [parseRoutes|
/ HomeR GET
/nest NestR:
/ NestIndexR GET POST
/#Int NestShowR GET POST
|]
We have defined a nested route called NestR here. A nested route is
created with the : after the route name.
Then, in a module for the route specifically, we can generate the route datatype and instances for later hooking in to the main instance.
module App.Routes.NestR where import App.Routes.Resources import Yesod.Core mkYesodOpts (setFocusOnNestedRoute NestR defaultOpts) App appResources
If you only want to generate the datatypes, you can separate things
further using mkYesodDataOpts and mkYesodDispatchOpts.
Finally, import that type into your main yesod macro code.
module App where import App.Routes.Resources (appResources) import App.Routes.NestR (NestR(..)) mkYesod App appResources
The call to mkYesod will delegate to the generated code for NestR
rather than regenerating it.
By default, defaultOpts starts unfocused (the whole route tree is
generated). Use unsetFocusOnNestedRoute to clear a previously-set focus.
For a full walkthrough — including subsites, linking to nested routes, and
why split sites should enable setNestedRouteFallthrough — see the guide at
https://github.com/yesodweb/yesod/blob/master/yesod-core/docs/split-route-compilation.md.
Since: 1.7.0.0
unsetFocusOnNestedRoute :: RouteOpts -> RouteOpts Source #
Clear any nested-route focus set by setFocusOnNestedRoute, so that
the whole route tree is generated.
defaultOpts already starts unfocused, so this is only needed to undo a
previous setFocusOnNestedRoute.
Since: 1.7.0.0
setParameterizedSubroute :: Bool -> RouteOpts -> RouteOpts Source #
If True, generate nested-discovery code (separate subroute datatypes and
RenderRouteNested dispatch instances) for a parameterized/ site instead
of the backwards-compatible inline output. The subroute datatypes then carry
the parent site's type variables so that the ParentSite / ParentArgs
associated types stay well-scoped.
Because the generated nested instances are parameterized over the site's
type variables, the splice emits instance heads with non-variable arguments;
a module using this typically needs FlexibleContexts, FlexibleInstances,
MultiParamTypeClasses, TypeFamilies and, for a parameterized subsite
whose master is determined by the subsite (a subsite -> master
functional dependency on the user's class), UndecidableInstances.
Monomorphic sites always use nested discovery regardless of this flag; see
discoveryMode.
Default: False.
Since: 1.6.28.0
setNestedRouteFallthrough :: Bool -> RouteOpts -> RouteOpts Source #
When True, a nested route that fails to match falls through to the
enclosing dispatch rather than throwing notFound. When False, a
non-matching nested route throws notFound.
Default: False.
Since: 1.7.0.0
Helpers
defaultGen :: IO Int Source #
Generate a random number uniformly distributed in the full range
of Int.
Note: Before 1.6.20, this generates pseudo-random number in an
unspecified range. The range size may not be a power of 2. Since
1.6.20, this uses a secure entropy source and generates in the full
range of Int.
Since: 1.6.21.0
getGetMaxExpires :: IO (IO Text) Source #
Default constructor for yreGetMaxExpires field. Low level
function for simple manual construction of YesodRunnerEnv.
Since: 1.4.29
Path pieces
Instances
| PathPiece Int16 # | |
Defined in Web.PathPieces | |
| PathPiece Int32 # | |
Defined in Web.PathPieces | |
| PathPiece Int64 # | |
Defined in Web.PathPieces | |
| PathPiece Int8 # | |
Defined in Web.PathPieces | |
| PathPiece Word16 # | |
Defined in Web.PathPieces | |
| PathPiece Word32 # | |
Defined in Web.PathPieces | |
| PathPiece Word64 # | |
Defined in Web.PathPieces | |
| PathPiece Word8 # | |
Defined in Web.PathPieces | |
| PathPiece Text # | |
Defined in Web.PathPieces | |
| PathPiece Text # | |
Defined in Web.PathPieces | |
| PathPiece Day # | |
Defined in Web.PathPieces | |
| PathPiece String # | |
Defined in Web.PathPieces | |
| PathPiece Integer # | |
Defined in Web.PathPieces | |
| PathPiece () # | |
Defined in Web.PathPieces | |
| PathPiece Bool # | |
Defined in Web.PathPieces | |
| PathPiece Int # | |
Defined in Web.PathPieces | |
| PathPiece Word # | |
Defined in Web.PathPieces | |
| PathPiece a => PathPiece (Maybe a) # | |
Defined in Web.PathPieces | |
class PathMultiPiece s where #
Instances
| PathPiece a => PathMultiPiece [a] # | |
Defined in Web.PathPieces | |
Convert to WAI
toWaiApp :: YesodDispatch site => site -> IO Application Source #
Same as toWaiAppPlain, but provides a default set of middlewares. This
set may change with future releases, but currently covers:
- Logging
- GZIP compression
- Automatic HEAD method handling
- Request method override with the _method query string parameter
- Accept header override with the _accept query string parameter
toWaiAppPlain :: YesodDispatch site => site -> IO Application Source #
Convert the given argument into a WAI application, executable with any WAI
handler. This function will provide no middlewares; if you want commonly
used middlewares, please use toWaiApp.
class RedirectUrl site url => UrlToDispatch url site where Source #
Build a WAI Application for site, indexed by a url type that can
be rendered to a route of site (via RedirectUrl).
Note that dispatch is purely path-based: the hand-written instances below
discard the url value (urlToDispatch _ = yesodDispatch) and route on the
request's pathInfo. The url argument exists only to select the instance
and to carry the RedirectUrl constraint — it is not consulted at runtime.
This is equivalent to YesodDispatch but allows us to vary on the
url type, which lets us demand additional constraints in test
contexts.
Since: 1.7.0.0
Instances
| YesodDispatch site => UrlToDispatch Text site Source # | |
Defined in Yesod.Core.Class.Dispatch Methods urlToDispatch :: Text -> YesodRunnerEnv site -> Application Source # | |
| YesodDispatch site => UrlToDispatch String site Source # | |
Defined in Yesod.Core.Class.Dispatch Methods urlToDispatch :: String -> YesodRunnerEnv site -> Application Source # | |
| YesodDispatch site => UrlToDispatch (Route site) site Source # | |
Defined in Yesod.Core.Class.Dispatch Methods urlToDispatch :: Route site -> YesodRunnerEnv site -> Application Source # | |
| (ParentSite route ~ site, YesodDispatchNested route, RedirectUrl site (WithParentArgs route), Yesod site, ToParentRoute route) => UrlToDispatch (WithParentArgs route) site Source # | This instance is the pattern upon which Since: 1.7.0.0 |
Defined in Yesod.Core.Class.Dispatch Methods urlToDispatch :: WithParentArgs route -> YesodRunnerEnv site -> Application Source # | |
| (YesodDispatch site, RedirectUrl site (Route site, a)) => UrlToDispatch (Route site, a) site Source # | |
Defined in Yesod.Core.Class.Dispatch Methods urlToDispatch :: (Route site, a) -> YesodRunnerEnv site -> Application Source # | |
mkYesodRunnerEnv :: Yesod site => site -> IO (YesodRunnerEnv site) Source #
Construct a YesodRunnerEnv for a site, initializing its logger, session
backend, and other runtime state. This is the environment threaded through
dispatch; toWaiAppPlain and friends build one for you, but it is exposed so
callers can construct and reuse a runner environment directly.
Since: 1.7.0.0
toWaiAppPlainNested :: (site ~ ParentSite route, Yesod site, YesodDispatchNested route, ToParentRoute route) => Proxy route -> ParentArgs route -> site -> IO Application Source #
Convert the given argument into a WAI application, executable with any WAI
handler. This function will provide no middlewares; if you want commonly
used middlewares, please use toWaiApp.
This function allows you to create an Application that only responds
to a subset of the site routes. This is really only useful for writing
tests, but it does allow you to write tests that only depend on a subset
of the handlers instead of all handlers.
Since: 1.7.0.0
toWaiAppYre :: YesodDispatch site => YesodRunnerEnv site -> Application Source #
Pure low level function to construct WAI application. Usefull when you need not standard way to run your app, or want to embed it inside another app.
Since: 1.4.29
toWaiAppYreNested :: (Yesod (ParentSite a), YesodDispatchNested a, ToParentRoute a) => Proxy a -> ParentArgs a -> YesodRunnerEnv (ParentSite a) -> Application Source #
Build a WAI Application that dispatches starting at a nested route
fragment a (rather than the whole ), given a
Route siteYesodRunnerEnv for the parent site and the parent route's ParentArgs.
Handles cleanPath redirects and a terminal 404 just like toWaiAppYre.
Since: 1.7.0.0
warp :: YesodDispatch site => Int -> site -> IO () Source #
A convenience method to run an application using the Warp webserver on the
specified port. Automatically calls toWaiApp. Provides a default set of
middlewares. This set may change at any point without a breaking version
number. Currently, it includes:
- Logging
- GZIP compression
- Automatic HEAD method handling
- Request method override with the _method query string parameter
- Accept header override with the _accept query string parameter
If you need more fine-grained control of middlewares, please use toWaiApp
directly.
Since 1.2.0
warpDebug :: YesodDispatch site => Int -> site -> IO () Source #
Deprecated: Please use warp instead
Deprecated synonym for warp.
warpEnv :: YesodDispatch site => site -> IO () Source #
Runs your application using default middlewares (i.e., via toWaiApp). It
reads port information from the PORT environment variable, as used by tools
such as Keter and the FP Complete School of Haskell.
Note that the exact behavior of this function may be modified slightly over time to work correctly with external tools, without a change to the type signature.
mkDefaultMiddlewares :: Logger -> IO Middleware Source #
A default set of middlewares.
Since 1.2.0
defaultMiddlewaresNoLogging :: Middleware Source #
All of the default middlewares, excluding logging.
Since 1.2.12
Subsite nested dispatch
class RenderRouteNested a => YesodSubDispatchNested a where Source #
Like YesodDispatchNested, but for subsites. This class enables
class-based delegation for nested routes within subsites, allowing
module separation and symmetry with YesodDispatchNested.
When a YesodSubDispatchNested instance exists for a nested route type,
mkYesodSubDispatch will delegate to it instead of inlining the dispatch.
Use mkYesodSubDispatchInstance to generate both YesodSubDispatch and
YesodSubDispatchNested instances in one splice.
Since: 1.7.0.0
Methods
yesodSubDispatchNested Source #
Arguments
| :: Proxy a | Type proxy to resolve ambiguity from non-injective type families |
| -> ParentArgs a | The dynamic arguments from the parent route |
| -> (a -> Route (ParentSite a)) | Function to wrap the nested route in the parent constructor |
| -> YesodSubRunnerEnv (ParentSite a) master | The subsite runner environment |
| -> Request | The full WAI request |
| -> Maybe ((Response -> IO ResponseReceived) -> IO ResponseReceived) | Returns |
Dispatches a request for a nested route fragment within a subsite.
Similar to yesodDispatchNested, but works with YesodSubRunnerEnv
instead of YesodRunnerEnv, making it suitable for subsites.
The master type is universally quantified since it's not determined
by the nested route type.
Since: 1.7.0.0
WAI subsites
newtype WaiSubsite Source #
Wrap up a normal WAI application as a Yesod subsite. Ignore parent site's middleware and isAuthorized.
Constructors
| WaiSubsite | |
Fields | |
Instances
newtype WaiSubsiteWithAuth Source #
Like WaiSubsite, but applies parent site's middleware and isAuthorized.
Since: 1.4.34
Constructors
| WaiSubsiteWithAuth | |
Fields | |
Instances
| ParseRoute WaiSubsiteWithAuth Source # | |||||
Defined in Yesod.Core.Types Methods parseRoute :: ([Text], [(Text, Text)]) -> Maybe (Route WaiSubsiteWithAuth) Source # | |||||
| RenderRoute WaiSubsiteWithAuth Source # | |||||
Defined in Yesod.Core.Types Associated Types
Methods renderRoute :: Route WaiSubsiteWithAuth -> ([Text], [(Text, Text)]) Source # | |||||
| YesodSubDispatch WaiSubsiteWithAuth master Source # | |||||
Defined in Yesod.Core.Class.Dispatch Methods yesodSubDispatch :: YesodSubRunnerEnv WaiSubsiteWithAuth master -> Application Source # | |||||
| Eq (Route WaiSubsiteWithAuth) Source # | |||||
Defined in Yesod.Core.Types Methods (==) :: Route WaiSubsiteWithAuth -> Route WaiSubsiteWithAuth -> Bool (/=) :: Route WaiSubsiteWithAuth -> Route WaiSubsiteWithAuth -> Bool | |||||
| Ord (Route WaiSubsiteWithAuth) Source # | |||||
Defined in Yesod.Core.Types Methods compare :: Route WaiSubsiteWithAuth -> Route WaiSubsiteWithAuth -> Ordering (<) :: Route WaiSubsiteWithAuth -> Route WaiSubsiteWithAuth -> Bool (<=) :: Route WaiSubsiteWithAuth -> Route WaiSubsiteWithAuth -> Bool (>) :: Route WaiSubsiteWithAuth -> Route WaiSubsiteWithAuth -> Bool (>=) :: Route WaiSubsiteWithAuth -> Route WaiSubsiteWithAuth -> Bool max :: Route WaiSubsiteWithAuth -> Route WaiSubsiteWithAuth -> Route WaiSubsiteWithAuth min :: Route WaiSubsiteWithAuth -> Route WaiSubsiteWithAuth -> Route WaiSubsiteWithAuth | |||||
| Read (Route WaiSubsiteWithAuth) Source # | |||||
Defined in Yesod.Core.Types Methods readsPrec :: Int -> ReadS (Route WaiSubsiteWithAuth) readList :: ReadS [Route WaiSubsiteWithAuth] readPrec :: ReadPrec (Route WaiSubsiteWithAuth) readListPrec :: ReadPrec [Route WaiSubsiteWithAuth] | |||||
| Show (Route WaiSubsiteWithAuth) Source # | |||||
Defined in Yesod.Core.Types Methods showsPrec :: Int -> Route WaiSubsiteWithAuth -> ShowS show :: Route WaiSubsiteWithAuth -> String showList :: [Route WaiSubsiteWithAuth] -> ShowS | |||||
| data Route WaiSubsiteWithAuth Source # | |||||
Defined in Yesod.Core.Types | |||||