yesod-core
Safe HaskellNone
LanguageHaskell2010

Yesod.Core.Dispatch

Synopsis

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.

mkYesod Source #

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

mkYesodWith Source #

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 #

mkYesodDispatchOpts :: RouteOpts -> String -> [ResourceTree String] -> Q [Dec] Source #

See mkYesodDataOpts

Since: 1.6.25.0

mkYesodSubDispatchInstance Source #

Arguments

:: String

Foundation type with optional context, e.g. "(MyClass a) => MySub a"

-> [ResourceTree String]

Resources (e.g. resourcesMySub)

-> 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:

  1. A YesodSubDispatch instance using mkYesodSubDispatch
  2. YesodSubDispatchNested instances 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. "(MyClass a) => MySub a"

-> [ResourceTree String]

Resources (e.g. resourcesMySub)

-> 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 [ResourceTree String] (the 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 [ResourceTree String] — exactly the form the 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

data TyArgs Source #

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)) 

Instances

Instances details
Eq TyArgs Source # 
Instance details

Defined in Yesod.Routes.TH.Types

Methods

(==) :: TyArgs -> TyArgs -> Bool

(/=) :: TyArgs -> TyArgs -> Bool

Show TyArgs Source # 
Instance details

Defined in Yesod.Routes.TH.Types

Methods

showsPrec :: Int -> TyArgs -> ShowS

show :: TyArgs -> String

showList :: [TyArgs] -> ShowS

Route generation options

data RouteOpts Source #

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:

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

class PathPiece s where #

Methods

fromPathPiece :: Text -> Maybe s #

toPathPiece :: s -> Text #

Instances

Instances details
PathPiece Int16 # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Int16 #

toPathPiece :: Int16 -> Text #

PathPiece Int32 # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Int32 #

toPathPiece :: Int32 -> Text #

PathPiece Int64 # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Int64 #

toPathPiece :: Int64 -> Text #

PathPiece Int8 # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Int8 #

toPathPiece :: Int8 -> Text #

PathPiece Word16 # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Word16 #

toPathPiece :: Word16 -> Text #

PathPiece Word32 # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Word32 #

toPathPiece :: Word32 -> Text #

PathPiece Word64 # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Word64 #

toPathPiece :: Word64 -> Text #

PathPiece Word8 # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Word8 #

toPathPiece :: Word8 -> Text #

PathPiece Text # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Text #

toPathPiece :: Text -> Text #

PathPiece Text # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Text #

toPathPiece :: Text -> Text #

PathPiece Day # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Day #

toPathPiece :: Day -> Text #

PathPiece String # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe String #

toPathPiece :: String -> Text #

PathPiece Integer # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Integer #

toPathPiece :: Integer -> Text #

PathPiece () # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe () #

toPathPiece :: () -> Text #

PathPiece Bool # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Bool #

toPathPiece :: Bool -> Text #

PathPiece Int # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Int #

toPathPiece :: Int -> Text #

PathPiece Word # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe Word #

toPathPiece :: Word -> Text #

PathPiece a => PathPiece (Maybe a) # 
Instance details

Defined in Web.PathPieces

Methods

fromPathPiece :: Text -> Maybe (Maybe a) #

toPathPiece :: Maybe a -> Text #

class PathMultiPiece s where #

Methods

fromPathMultiPiece :: [Text] -> Maybe s #

toPathMultiPiece :: s -> [Text] #

Instances

Instances details
PathPiece a => PathMultiPiece [a] # 
Instance details

Defined in Web.PathPieces

Methods

fromPathMultiPiece :: [Text] -> Maybe [a] #

toPathMultiPiece :: [a] -> [Text] #

type Texts = [Text] Source #

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

Methods

urlToDispatch :: url -> YesodRunnerEnv site -> Application Source #

Since: 1.7.0.0

Instances

Instances details
YesodDispatch site => UrlToDispatch Text site Source # 
Instance details

Defined in Yesod.Core.Class.Dispatch

Methods

urlToDispatch :: Text -> YesodRunnerEnv site -> Application Source #

YesodDispatch site => UrlToDispatch String site Source # 
Instance details

Defined in Yesod.Core.Class.Dispatch

Methods

urlToDispatch :: String -> YesodRunnerEnv site -> Application Source #

YesodDispatch site => UrlToDispatch (Route site) site Source # 
Instance details

Defined in Yesod.Core.Class.Dispatch

(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 UrlToDispatch instances are generated for subsite fragments. Given the constraints, we are able to call toWaiAppYreNested at the route type with the correct arguments. This allows us to create an application for a fragment of a site.

Since: 1.7.0.0

Instance details

Defined in Yesod.Core.Class.Dispatch

(YesodDispatch site, RedirectUrl site (Route site, a)) => UrlToDispatch (Route site, a) site Source # 
Instance details

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 Route site), given a YesodRunnerEnv 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 Nothing for fallthrough, or Just a continuation

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 

Instances

Instances details
ParseRoute WaiSubsite Source # 
Instance details

Defined in Yesod.Core.Types

Methods

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

RenderRoute WaiSubsite Source # 
Instance details

Defined in Yesod.Core.Types

Associated Types

data Route WaiSubsite 
Instance details

Defined in Yesod.Core.Types

data Route WaiSubsite = WaiSubsiteRoute [Text] [(Text, Text)]

Methods

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

YesodSubDispatch WaiSubsite master Source # 
Instance details

Defined in Yesod.Core.Class.Dispatch

Eq (Route WaiSubsite) Source # 
Instance details

Defined in Yesod.Core.Types

Ord (Route WaiSubsite) Source # 
Instance details

Defined in Yesod.Core.Types

Read (Route WaiSubsite) Source # 
Instance details

Defined in Yesod.Core.Types

Methods

readsPrec :: Int -> ReadS (Route WaiSubsite)

readList :: ReadS [Route WaiSubsite]

readPrec :: ReadPrec (Route WaiSubsite)

readListPrec :: ReadPrec [Route WaiSubsite]

Show (Route WaiSubsite) Source # 
Instance details

Defined in Yesod.Core.Types

Methods

showsPrec :: Int -> Route WaiSubsite -> ShowS

show :: Route WaiSubsite -> String

showList :: [Route WaiSubsite] -> ShowS

data Route WaiSubsite Source # 
Instance details

Defined in Yesod.Core.Types

data Route WaiSubsite = WaiSubsiteRoute [Text] [(Text, Text)]

newtype WaiSubsiteWithAuth Source #

Like WaiSubsite, but applies parent site's middleware and isAuthorized.

Since: 1.4.34

Instances

Instances details
ParseRoute WaiSubsiteWithAuth Source # 
Instance details

Defined in Yesod.Core.Types

Methods

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

RenderRoute WaiSubsiteWithAuth Source # 
Instance details

Defined in Yesod.Core.Types

Associated Types

data Route WaiSubsiteWithAuth 
Instance details

Defined in Yesod.Core.Types

data Route WaiSubsiteWithAuth = WaiSubsiteWithAuthRoute [Text] [(Text, Text)]

Methods

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

YesodSubDispatch WaiSubsiteWithAuth master Source # 
Instance details

Defined in Yesod.Core.Class.Dispatch

Eq (Route WaiSubsiteWithAuth) Source # 
Instance details

Defined in Yesod.Core.Types

Ord (Route WaiSubsiteWithAuth) Source # 
Instance details

Defined in Yesod.Core.Types

Read (Route WaiSubsiteWithAuth) Source # 
Instance details

Defined in Yesod.Core.Types

Show (Route WaiSubsiteWithAuth) Source # 
Instance details

Defined in Yesod.Core.Types

data Route WaiSubsiteWithAuth Source # 
Instance details

Defined in Yesod.Core.Types

data Route WaiSubsiteWithAuth = WaiSubsiteWithAuthRoute [Text] [(Text, Text)]